diff --git a/.clang-format b/.clang-format new file mode 100644 index 00000000..18c50583 --- /dev/null +++ b/.clang-format @@ -0,0 +1,45 @@ +# A .clang-format file to adhere to the K&R style +# - CLANG-FORMAT STYLE OPTIONS: https://clang.llvm.org/docs/ClangFormatStyleOptions.html +# +# Author: Munseong Jeong + +BasedOnStyle: LLVM +IndentWidth: 4 +UseTab: Never + +BreakBeforeBraces: Linux +BraceWrapping: + AfterControlStatement: false + AfterFunction: true + AfterClass: false + AfterStruct: false + AfterUnion: false + AfterNamespace: false + AfterEnum: false + BeforeCatch: false + BeforeElse: false + IndentBraces: false + +ContinuationIndentWidth: 0 +AlignAfterOpenBracket: false +AllowShortIfStatementsOnASingleLine: false +AllowShortLoopsOnASingleLine: false +AllowShortBlocksOnASingleLine: Always +IndentCaseLabels: false +SpaceAfterCStyleCast: true +AllowShortFunctionsOnASingleLine: None +ColumnLimit: 80 +MaxEmptyLinesToKeep: 1 +Cpp11BracedListStyle: false +AlignTrailingComments: true +ReflowComments: true + +SpacesBeforeTrailingComments: 2 +IncludeBlocks: Regroup +IncludeCategories: + - Regex: '<[[:alnum:].]+>' + Priority: 1 + - Regex: '.*' + Priority: 2 +SortIncludes: CaseSensitive +AlignEscapedNewlines: Left \ No newline at end of file diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml new file mode 100644 index 00000000..3eaf2a46 --- /dev/null +++ b/.github/FUNDING.yml @@ -0,0 +1,3 @@ +# Donate to us! + +https://ko-fi.com/souldbminer diff --git a/.gitignore b/.gitignore index b795ef9e..5234451e 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,7 @@ *.DS_Store .vscode/ -build/ dist/ -.pyc \ No newline at end of file +.pyc +build/ +__pycache__/ +build diff --git a/.gitmodules b/.gitmodules index e69de29b..d6da4499 100644 --- a/.gitmodules +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "source/sys-clk/overlay/lib/libultrahand"] + path = source/sys-clk/overlay/lib/libultrahand + url = https://github.com/ppkantorski/libultrahand.git diff --git a/LICENSE b/LICENSE index de2c221c..1ccef1f1 100644 --- a/LICENSE +++ b/LICENSE @@ -1,10 +1,10 @@ - "libstratosphere", "loader" from Atmosphere-NX and "memtester" are licensed under GPL v2. -- "libultrahand" by b0redtoauth is licensed under the CC-BY-4.0 license, which is compatible with GPLv2 +- "libultrahand" by b0redt0death is licensed under the CC-BY-4.0 license, which is compatible with GPLv2 - Tinymembench is under MIT license, which is compatible with GPL v2. -- Although "sys-clk" uses permissive license, all modifications towards it in this repo ("sys-clk-OC") are licensed under GPL v2. +- Although "sys-clk" uses permissive license, all modifications towards it in this repo ("hoc-sys") are licensed under GPL v2. GNU GENERAL PUBLIC LICENSE diff --git a/README.md b/README.md index 73219487..32beca37 100644 --- a/README.md +++ b/README.md @@ -24,7 +24,7 @@ --- -## 🌀 About +## About **Horizon OC** is an open-source overclocking tool for Nintendo Switch consoles running **Atmosphere custom firmware**. It enables advanced CPU, GPU, and RAM tuning with user-friendly configuration tools. @@ -40,8 +40,8 @@ It enables advanced CPU, GPU, and RAM tuning with user-friendly configuration to * Built-in configurator * Compatible with most homebrew -> ⚡ *Higher (potentially dangerous) frequencies are unlockable.* -> ⚙️ *Exact maximum values vary per console.* +> *Higher (potentially dangerous) frequencies are unlockable.* +> *Exact maximum values vary per console.* --- @@ -84,12 +84,14 @@ It enables advanced CPU, GPU, and RAM tuning with user-friendly configuration to ``` 3. Move the cloned folder into `build/`. 4. Insert your `Source/stratosphere` folder into `build/`. -5. Run: +5. Run: (On Windows you need to use "make -j %NUMBER_OF_PROCESSORS%") ```bash ./build.sh ``` + + To build the Configurator: ```bash diff --git a/Source/Atmosphere-Patches/secmon_define_emc_access_table.inc b/Source/Atmosphere-Patches/secmon_define_emc_access_table.inc new file mode 100644 index 00000000..161f77c6 --- /dev/null +++ b/Source/Atmosphere-Patches/secmon_define_emc_access_table.inc @@ -0,0 +1,25 @@ +/* + * Copyright (c) Atmosphère-NX + * + * 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 . + */ + +#define __ACCESS_TABLE_NAME__ EmcAccessTable +#define __ACCESS_TABLE_ADDRESS__ MemoryRegionPhysicalDeviceExternalMemoryController.GetAddress() +#define __ACCESS_TABLE_INC__ "secmon_emc_access_table_data.inc" + +#include "secmon_define_access_table.inc" + +#undef __ACCESS_TABLE_INC__ +#undef __ACCESS_TABLE_ADDRESS__ +#undef __ACCESS_TABLE_NAME__ diff --git a/Source/Atmosphere-Patches/secmon_emc_access_table_data.inc b/Source/Atmosphere-Patches/secmon_emc_access_table_data.inc new file mode 100644 index 00000000..6089047e --- /dev/null +++ b/Source/Atmosphere-Patches/secmon_emc_access_table_data.inc @@ -0,0 +1,967 @@ +/* + * Copyright (c) Atmosphère-NX + * + * 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 . + */ + +SetRegisterAllowed(0x0); +SetRegisterAllowed(0x4); +SetRegisterAllowed(0x8); +SetRegisterAllowed(0xC); +SetRegisterAllowed(0x10); +SetRegisterAllowed(0x14); +SetRegisterAllowed(0x18); +SetRegisterAllowed(0x1C); +SetRegisterAllowed(0x20); +SetRegisterAllowed(0x24); +SetRegisterAllowed(0x28); +SetRegisterAllowed(0x2C); +SetRegisterAllowed(0x30); +SetRegisterAllowed(0x34); +SetRegisterAllowed(0x38); +SetRegisterAllowed(0x3C); +SetRegisterAllowed(0x40); +SetRegisterAllowed(0x44); +SetRegisterAllowed(0x48); +SetRegisterAllowed(0x4C); +SetRegisterAllowed(0x50); +SetRegisterAllowed(0x54); +SetRegisterAllowed(0x58); +SetRegisterAllowed(0x5C); +SetRegisterAllowed(0x60); +SetRegisterAllowed(0x64); +SetRegisterAllowed(0x68); +SetRegisterAllowed(0x6C); +SetRegisterAllowed(0x70); +SetRegisterAllowed(0x74); +SetRegisterAllowed(0x78); +SetRegisterAllowed(0x7C); +SetRegisterAllowed(0x80); +SetRegisterAllowed(0x84); +SetRegisterAllowed(0x88); +SetRegisterAllowed(0x8C); +SetRegisterAllowed(0x90); +SetRegisterAllowed(0x94); +SetRegisterAllowed(0x98); +SetRegisterAllowed(0x9C); +SetRegisterAllowed(0xA0); +SetRegisterAllowed(0xA4); +SetRegisterAllowed(0xA8); +SetRegisterAllowed(0xAC); +SetRegisterAllowed(0xB0); +SetRegisterAllowed(0xB4); +SetRegisterAllowed(0xB8); +SetRegisterAllowed(0xBC); +SetRegisterAllowed(0xC0); +SetRegisterAllowed(0xC4); +SetRegisterAllowed(0xC8); +SetRegisterAllowed(0xCC); +SetRegisterAllowed(0xD0); +SetRegisterAllowed(0xD4); +SetRegisterAllowed(0xD8); +SetRegisterAllowed(0xDC); +SetRegisterAllowed(0xE0); +SetRegisterAllowed(0xE4); +SetRegisterAllowed(0xE8); +SetRegisterAllowed(0xEC); +SetRegisterAllowed(0xF0); +SetRegisterAllowed(0xF4); +SetRegisterAllowed(0xF8); +SetRegisterAllowed(0xFC); +SetRegisterAllowed(0x100); +SetRegisterAllowed(0x104); +SetRegisterAllowed(0x108); +SetRegisterAllowed(0x10C); +SetRegisterAllowed(0x110); +SetRegisterAllowed(0x114); +SetRegisterAllowed(0x118); +SetRegisterAllowed(0x11C); +SetRegisterAllowed(0x120); +SetRegisterAllowed(0x124); +SetRegisterAllowed(0x128); +SetRegisterAllowed(0x12C); +SetRegisterAllowed(0x130); +SetRegisterAllowed(0x134); +SetRegisterAllowed(0x138); +SetRegisterAllowed(0x13C); +SetRegisterAllowed(0x140); +SetRegisterAllowed(0x144); +SetRegisterAllowed(0x148); +SetRegisterAllowed(0x14C); +SetRegisterAllowed(0x150); +SetRegisterAllowed(0x154); +SetRegisterAllowed(0x158); +SetRegisterAllowed(0x15C); +SetRegisterAllowed(0x160); +SetRegisterAllowed(0x164); +SetRegisterAllowed(0x168); +SetRegisterAllowed(0x16C); +SetRegisterAllowed(0x170); +SetRegisterAllowed(0x174); +SetRegisterAllowed(0x178); +SetRegisterAllowed(0x17C); +SetRegisterAllowed(0x180); +SetRegisterAllowed(0x184); +SetRegisterAllowed(0x188); +SetRegisterAllowed(0x18C); +SetRegisterAllowed(0x190); +SetRegisterAllowed(0x194); +SetRegisterAllowed(0x198); +SetRegisterAllowed(0x19C); +SetRegisterAllowed(0x1A0); +SetRegisterAllowed(0x1A4); +SetRegisterAllowed(0x1A8); +SetRegisterAllowed(0x1AC); +SetRegisterAllowed(0x1B0); +SetRegisterAllowed(0x1B4); +SetRegisterAllowed(0x1B8); +SetRegisterAllowed(0x1BC); +SetRegisterAllowed(0x1C0); +SetRegisterAllowed(0x1C4); +SetRegisterAllowed(0x1C8); +SetRegisterAllowed(0x1CC); +SetRegisterAllowed(0x1D0); +SetRegisterAllowed(0x1D4); +SetRegisterAllowed(0x1D8); +SetRegisterAllowed(0x1DC); +SetRegisterAllowed(0x1E0); +SetRegisterAllowed(0x1E4); +SetRegisterAllowed(0x1E8); +SetRegisterAllowed(0x1EC); +SetRegisterAllowed(0x1F0); +SetRegisterAllowed(0x1F4); +SetRegisterAllowed(0x1F8); +SetRegisterAllowed(0x1FC); +SetRegisterAllowed(0x200); +SetRegisterAllowed(0x204); +SetRegisterAllowed(0x208); +SetRegisterAllowed(0x20C); +SetRegisterAllowed(0x210); +SetRegisterAllowed(0x214); +SetRegisterAllowed(0x218); +SetRegisterAllowed(0x21C); +SetRegisterAllowed(0x220); +SetRegisterAllowed(0x224); +SetRegisterAllowed(0x228); +SetRegisterAllowed(0x22C); +SetRegisterAllowed(0x230); +SetRegisterAllowed(0x234); +SetRegisterAllowed(0x238); +SetRegisterAllowed(0x23C); +SetRegisterAllowed(0x240); +SetRegisterAllowed(0x244); +SetRegisterAllowed(0x248); +SetRegisterAllowed(0x24C); +SetRegisterAllowed(0x250); +SetRegisterAllowed(0x254); +SetRegisterAllowed(0x258); +SetRegisterAllowed(0x25C); +SetRegisterAllowed(0x260); +SetRegisterAllowed(0x264); +SetRegisterAllowed(0x268); +SetRegisterAllowed(0x26C); +SetRegisterAllowed(0x270); +SetRegisterAllowed(0x274); +SetRegisterAllowed(0x278); +SetRegisterAllowed(0x27C); +SetRegisterAllowed(0x280); +SetRegisterAllowed(0x284); +SetRegisterAllowed(0x288); +SetRegisterAllowed(0x28C); +SetRegisterAllowed(0x290); +SetRegisterAllowed(0x294); +SetRegisterAllowed(0x298); +SetRegisterAllowed(0x29C); +SetRegisterAllowed(0x2A0); +SetRegisterAllowed(0x2A4); +SetRegisterAllowed(0x2A8); +SetRegisterAllowed(0x2AC); +SetRegisterAllowed(0x2B0); +SetRegisterAllowed(0x2B4); +SetRegisterAllowed(0x2B8); +SetRegisterAllowed(0x2BC); +SetRegisterAllowed(0x2C0); +SetRegisterAllowed(0x2C4); +SetRegisterAllowed(0x2C8); +SetRegisterAllowed(0x2CC); +SetRegisterAllowed(0x2D0); +SetRegisterAllowed(0x2D4); +SetRegisterAllowed(0x2D8); +SetRegisterAllowed(0x2DC); +SetRegisterAllowed(0x2E0); +SetRegisterAllowed(0x2E4); +SetRegisterAllowed(0x2E8); +SetRegisterAllowed(0x2EC); +SetRegisterAllowed(0x2F0); +SetRegisterAllowed(0x2F4); +SetRegisterAllowed(0x2F8); +SetRegisterAllowed(0x2FC); +SetRegisterAllowed(0x300); +SetRegisterAllowed(0x304); +SetRegisterAllowed(0x308); +SetRegisterAllowed(0x30C); +SetRegisterAllowed(0x310); +SetRegisterAllowed(0x314); +SetRegisterAllowed(0x318); +SetRegisterAllowed(0x31C); +SetRegisterAllowed(0x320); +SetRegisterAllowed(0x324); +SetRegisterAllowed(0x328); +SetRegisterAllowed(0x32C); +SetRegisterAllowed(0x330); +SetRegisterAllowed(0x334); +SetRegisterAllowed(0x338); +SetRegisterAllowed(0x33C); +SetRegisterAllowed(0x340); +SetRegisterAllowed(0x344); +SetRegisterAllowed(0x348); +SetRegisterAllowed(0x34C); +SetRegisterAllowed(0x350); +SetRegisterAllowed(0x354); +SetRegisterAllowed(0x358); +SetRegisterAllowed(0x35C); +SetRegisterAllowed(0x360); +SetRegisterAllowed(0x364); +SetRegisterAllowed(0x368); +SetRegisterAllowed(0x36C); +SetRegisterAllowed(0x370); +SetRegisterAllowed(0x374); +SetRegisterAllowed(0x378); +SetRegisterAllowed(0x37C); +SetRegisterAllowed(0x380); +SetRegisterAllowed(0x384); +SetRegisterAllowed(0x388); +SetRegisterAllowed(0x38C); +SetRegisterAllowed(0x390); +SetRegisterAllowed(0x394); +SetRegisterAllowed(0x398); +SetRegisterAllowed(0x39C); +SetRegisterAllowed(0x3A0); +SetRegisterAllowed(0x3A4); +SetRegisterAllowed(0x3A8); +SetRegisterAllowed(0x3AC); +SetRegisterAllowed(0x3B0); +SetRegisterAllowed(0x3B4); +SetRegisterAllowed(0x3B8); +SetRegisterAllowed(0x3BC); +SetRegisterAllowed(0x3C0); +SetRegisterAllowed(0x3C4); +SetRegisterAllowed(0x3C8); +SetRegisterAllowed(0x3CC); +SetRegisterAllowed(0x3D0); +SetRegisterAllowed(0x3D4); +SetRegisterAllowed(0x3D8); +SetRegisterAllowed(0x3DC); +SetRegisterAllowed(0x3E0); +SetRegisterAllowed(0x3E4); +SetRegisterAllowed(0x3E8); +SetRegisterAllowed(0x3EC); +SetRegisterAllowed(0x3F0); +SetRegisterAllowed(0x3F4); +SetRegisterAllowed(0x3F8); +SetRegisterAllowed(0x3FC); +SetRegisterAllowed(0x400); +SetRegisterAllowed(0x404); +SetRegisterAllowed(0x408); +SetRegisterAllowed(0x40C); +SetRegisterAllowed(0x410); +SetRegisterAllowed(0x414); +SetRegisterAllowed(0x418); +SetRegisterAllowed(0x41C); +SetRegisterAllowed(0x420); +SetRegisterAllowed(0x424); +SetRegisterAllowed(0x428); +SetRegisterAllowed(0x42C); +SetRegisterAllowed(0x430); +SetRegisterAllowed(0x434); +SetRegisterAllowed(0x438); +SetRegisterAllowed(0x43C); +SetRegisterAllowed(0x440); +SetRegisterAllowed(0x444); +SetRegisterAllowed(0x448); +SetRegisterAllowed(0x44C); +SetRegisterAllowed(0x450); +SetRegisterAllowed(0x454); +SetRegisterAllowed(0x458); +SetRegisterAllowed(0x45C); +SetRegisterAllowed(0x460); +SetRegisterAllowed(0x464); +SetRegisterAllowed(0x468); +SetRegisterAllowed(0x46C); +SetRegisterAllowed(0x470); +SetRegisterAllowed(0x474); +SetRegisterAllowed(0x478); +SetRegisterAllowed(0x47C); +SetRegisterAllowed(0x480); +SetRegisterAllowed(0x484); +SetRegisterAllowed(0x488); +SetRegisterAllowed(0x48C); +SetRegisterAllowed(0x490); +SetRegisterAllowed(0x494); +SetRegisterAllowed(0x498); +SetRegisterAllowed(0x49C); +SetRegisterAllowed(0x4A0); +SetRegisterAllowed(0x4A4); +SetRegisterAllowed(0x4A8); +SetRegisterAllowed(0x4AC); +SetRegisterAllowed(0x4B0); +SetRegisterAllowed(0x4B4); +SetRegisterAllowed(0x4B8); +SetRegisterAllowed(0x4BC); +SetRegisterAllowed(0x4C0); +SetRegisterAllowed(0x4C4); +SetRegisterAllowed(0x4C8); +SetRegisterAllowed(0x4CC); +SetRegisterAllowed(0x4D0); +SetRegisterAllowed(0x4D4); +SetRegisterAllowed(0x4D8); +SetRegisterAllowed(0x4DC); +SetRegisterAllowed(0x4E0); +SetRegisterAllowed(0x4E4); +SetRegisterAllowed(0x4E8); +SetRegisterAllowed(0x4EC); +SetRegisterAllowed(0x4F0); +SetRegisterAllowed(0x4F4); +SetRegisterAllowed(0x4F8); +SetRegisterAllowed(0x4FC); +SetRegisterAllowed(0x500); +SetRegisterAllowed(0x504); +SetRegisterAllowed(0x508); +SetRegisterAllowed(0x50C); +SetRegisterAllowed(0x510); +SetRegisterAllowed(0x514); +SetRegisterAllowed(0x518); +SetRegisterAllowed(0x51C); +SetRegisterAllowed(0x520); +SetRegisterAllowed(0x524); +SetRegisterAllowed(0x528); +SetRegisterAllowed(0x52C); +SetRegisterAllowed(0x530); +SetRegisterAllowed(0x534); +SetRegisterAllowed(0x538); +SetRegisterAllowed(0x53C); +SetRegisterAllowed(0x540); +SetRegisterAllowed(0x544); +SetRegisterAllowed(0x548); +SetRegisterAllowed(0x54C); +SetRegisterAllowed(0x550); +SetRegisterAllowed(0x554); +SetRegisterAllowed(0x558); +SetRegisterAllowed(0x55C); +SetRegisterAllowed(0x560); +SetRegisterAllowed(0x564); +SetRegisterAllowed(0x568); +SetRegisterAllowed(0x56C); +SetRegisterAllowed(0x570); +SetRegisterAllowed(0x574); +SetRegisterAllowed(0x578); +SetRegisterAllowed(0x57C); +SetRegisterAllowed(0x580); +SetRegisterAllowed(0x584); +SetRegisterAllowed(0x588); +SetRegisterAllowed(0x58C); +SetRegisterAllowed(0x590); +SetRegisterAllowed(0x594); +SetRegisterAllowed(0x598); +SetRegisterAllowed(0x59C); +SetRegisterAllowed(0x5A0); +SetRegisterAllowed(0x5A4); +SetRegisterAllowed(0x5A8); +SetRegisterAllowed(0x5AC); +SetRegisterAllowed(0x5B0); +SetRegisterAllowed(0x5B4); +SetRegisterAllowed(0x5B8); +SetRegisterAllowed(0x5BC); +SetRegisterAllowed(0x5C0); +SetRegisterAllowed(0x5C4); +SetRegisterAllowed(0x5C8); +SetRegisterAllowed(0x5CC); +SetRegisterAllowed(0x5D0); +SetRegisterAllowed(0x5D4); +SetRegisterAllowed(0x5D8); +SetRegisterAllowed(0x5DC); +SetRegisterAllowed(0x5E0); +SetRegisterAllowed(0x5E4); +SetRegisterAllowed(0x5E8); +SetRegisterAllowed(0x5EC); +SetRegisterAllowed(0x5F0); +SetRegisterAllowed(0x5F4); +SetRegisterAllowed(0x5F8); +SetRegisterAllowed(0x5FC); +SetRegisterAllowed(0x600); +SetRegisterAllowed(0x604); +SetRegisterAllowed(0x608); +SetRegisterAllowed(0x60C); +SetRegisterAllowed(0x610); +SetRegisterAllowed(0x614); +SetRegisterAllowed(0x618); +SetRegisterAllowed(0x61C); +SetRegisterAllowed(0x620); +SetRegisterAllowed(0x624); +SetRegisterAllowed(0x628); +SetRegisterAllowed(0x62C); +SetRegisterAllowed(0x630); +SetRegisterAllowed(0x634); +SetRegisterAllowed(0x638); +SetRegisterAllowed(0x63C); +SetRegisterAllowed(0x640); +SetRegisterAllowed(0x644); +SetRegisterAllowed(0x648); +SetRegisterAllowed(0x64C); +SetRegisterAllowed(0x650); +SetRegisterAllowed(0x654); +SetRegisterAllowed(0x658); +SetRegisterAllowed(0x65C); +SetRegisterAllowed(0x660); +SetRegisterAllowed(0x664); +SetRegisterAllowed(0x668); +SetRegisterAllowed(0x66C); +SetRegisterAllowed(0x670); +SetRegisterAllowed(0x674); +SetRegisterAllowed(0x678); +SetRegisterAllowed(0x67C); +SetRegisterAllowed(0x680); +SetRegisterAllowed(0x684); +SetRegisterAllowed(0x688); +SetRegisterAllowed(0x68C); +SetRegisterAllowed(0x690); +SetRegisterAllowed(0x694); +SetRegisterAllowed(0x698); +SetRegisterAllowed(0x69C); +SetRegisterAllowed(0x6A0); +SetRegisterAllowed(0x6A4); +SetRegisterAllowed(0x6A8); +SetRegisterAllowed(0x6AC); +SetRegisterAllowed(0x6B0); +SetRegisterAllowed(0x6B4); +SetRegisterAllowed(0x6B8); +SetRegisterAllowed(0x6BC); +SetRegisterAllowed(0x6C0); +SetRegisterAllowed(0x6C4); +SetRegisterAllowed(0x6C8); +SetRegisterAllowed(0x6CC); +SetRegisterAllowed(0x6D0); +SetRegisterAllowed(0x6D4); +SetRegisterAllowed(0x6D8); +SetRegisterAllowed(0x6DC); +SetRegisterAllowed(0x6E0); +SetRegisterAllowed(0x6E4); +SetRegisterAllowed(0x6E8); +SetRegisterAllowed(0x6EC); +SetRegisterAllowed(0x6F0); +SetRegisterAllowed(0x6F4); +SetRegisterAllowed(0x6F8); +SetRegisterAllowed(0x6FC); +SetRegisterAllowed(0x700); +SetRegisterAllowed(0x704); +SetRegisterAllowed(0x708); +SetRegisterAllowed(0x70C); +SetRegisterAllowed(0x710); +SetRegisterAllowed(0x714); +SetRegisterAllowed(0x718); +SetRegisterAllowed(0x71C); +SetRegisterAllowed(0x720); +SetRegisterAllowed(0x724); +SetRegisterAllowed(0x728); +SetRegisterAllowed(0x72C); +SetRegisterAllowed(0x730); +SetRegisterAllowed(0x734); +SetRegisterAllowed(0x738); +SetRegisterAllowed(0x73C); +SetRegisterAllowed(0x740); +SetRegisterAllowed(0x744); +SetRegisterAllowed(0x748); +SetRegisterAllowed(0x74C); +SetRegisterAllowed(0x750); +SetRegisterAllowed(0x754); +SetRegisterAllowed(0x758); +SetRegisterAllowed(0x75C); +SetRegisterAllowed(0x760); +SetRegisterAllowed(0x764); +SetRegisterAllowed(0x768); +SetRegisterAllowed(0x76C); +SetRegisterAllowed(0x770); +SetRegisterAllowed(0x774); +SetRegisterAllowed(0x778); +SetRegisterAllowed(0x77C); +SetRegisterAllowed(0x780); +SetRegisterAllowed(0x784); +SetRegisterAllowed(0x788); +SetRegisterAllowed(0x78C); +SetRegisterAllowed(0x790); +SetRegisterAllowed(0x794); +SetRegisterAllowed(0x798); +SetRegisterAllowed(0x79C); +SetRegisterAllowed(0x7A0); +SetRegisterAllowed(0x7A4); +SetRegisterAllowed(0x7A8); +SetRegisterAllowed(0x7AC); +SetRegisterAllowed(0x7B0); +SetRegisterAllowed(0x7B4); +SetRegisterAllowed(0x7B8); +SetRegisterAllowed(0x7BC); +SetRegisterAllowed(0x7C0); +SetRegisterAllowed(0x7C4); +SetRegisterAllowed(0x7C8); +SetRegisterAllowed(0x7CC); +SetRegisterAllowed(0x7D0); +SetRegisterAllowed(0x7D4); +SetRegisterAllowed(0x7D8); +SetRegisterAllowed(0x7DC); +SetRegisterAllowed(0x7E0); +SetRegisterAllowed(0x7E4); +SetRegisterAllowed(0x7E8); +SetRegisterAllowed(0x7EC); +SetRegisterAllowed(0x7F0); +SetRegisterAllowed(0x7F4); +SetRegisterAllowed(0x7F8); +SetRegisterAllowed(0x7FC); +SetRegisterAllowed(0x800); +SetRegisterAllowed(0x804); +SetRegisterAllowed(0x808); +SetRegisterAllowed(0x80C); +SetRegisterAllowed(0x810); +SetRegisterAllowed(0x814); +SetRegisterAllowed(0x818); +SetRegisterAllowed(0x81C); +SetRegisterAllowed(0x820); +SetRegisterAllowed(0x824); +SetRegisterAllowed(0x828); +SetRegisterAllowed(0x82C); +SetRegisterAllowed(0x830); +SetRegisterAllowed(0x834); +SetRegisterAllowed(0x838); +SetRegisterAllowed(0x83C); +SetRegisterAllowed(0x840); +SetRegisterAllowed(0x844); +SetRegisterAllowed(0x848); +SetRegisterAllowed(0x84C); +SetRegisterAllowed(0x850); +SetRegisterAllowed(0x854); +SetRegisterAllowed(0x858); +SetRegisterAllowed(0x85C); +SetRegisterAllowed(0x860); +SetRegisterAllowed(0x864); +SetRegisterAllowed(0x868); +SetRegisterAllowed(0x86C); +SetRegisterAllowed(0x870); +SetRegisterAllowed(0x874); +SetRegisterAllowed(0x878); +SetRegisterAllowed(0x87C); +SetRegisterAllowed(0x880); +SetRegisterAllowed(0x884); +SetRegisterAllowed(0x888); +SetRegisterAllowed(0x88C); +SetRegisterAllowed(0x890); +SetRegisterAllowed(0x894); +SetRegisterAllowed(0x898); +SetRegisterAllowed(0x89C); +SetRegisterAllowed(0x8A0); +SetRegisterAllowed(0x8A4); +SetRegisterAllowed(0x8A8); +SetRegisterAllowed(0x8AC); +SetRegisterAllowed(0x8B0); +SetRegisterAllowed(0x8B4); +SetRegisterAllowed(0x8B8); +SetRegisterAllowed(0x8BC); +SetRegisterAllowed(0x8C0); +SetRegisterAllowed(0x8C4); +SetRegisterAllowed(0x8C8); +SetRegisterAllowed(0x8CC); +SetRegisterAllowed(0x8D0); +SetRegisterAllowed(0x8D4); +SetRegisterAllowed(0x8D8); +SetRegisterAllowed(0x8DC); +SetRegisterAllowed(0x8E0); +SetRegisterAllowed(0x8E4); +SetRegisterAllowed(0x8E8); +SetRegisterAllowed(0x8EC); +SetRegisterAllowed(0x8F0); +SetRegisterAllowed(0x8F4); +SetRegisterAllowed(0x8F8); +SetRegisterAllowed(0x8FC); +SetRegisterAllowed(0x900); +SetRegisterAllowed(0x904); +SetRegisterAllowed(0x908); +SetRegisterAllowed(0x90C); +SetRegisterAllowed(0x910); +SetRegisterAllowed(0x914); +SetRegisterAllowed(0x918); +SetRegisterAllowed(0x91C); +SetRegisterAllowed(0x920); +SetRegisterAllowed(0x924); +SetRegisterAllowed(0x928); +SetRegisterAllowed(0x92C); +SetRegisterAllowed(0x930); +SetRegisterAllowed(0x934); +SetRegisterAllowed(0x938); +SetRegisterAllowed(0x93C); +SetRegisterAllowed(0x940); +SetRegisterAllowed(0x944); +SetRegisterAllowed(0x948); +SetRegisterAllowed(0x94C); +SetRegisterAllowed(0x950); +SetRegisterAllowed(0x954); +SetRegisterAllowed(0x958); +SetRegisterAllowed(0x95C); +SetRegisterAllowed(0x960); +SetRegisterAllowed(0x964); +SetRegisterAllowed(0x968); +SetRegisterAllowed(0x96C); +SetRegisterAllowed(0x970); +SetRegisterAllowed(0x974); +SetRegisterAllowed(0x978); +SetRegisterAllowed(0x97C); +SetRegisterAllowed(0x980); +SetRegisterAllowed(0x984); +SetRegisterAllowed(0x988); +SetRegisterAllowed(0x98C); +SetRegisterAllowed(0x990); +SetRegisterAllowed(0x994); +SetRegisterAllowed(0x998); +SetRegisterAllowed(0x99C); +SetRegisterAllowed(0x9A0); +SetRegisterAllowed(0x9A4); +SetRegisterAllowed(0x9A8); +SetRegisterAllowed(0x9AC); +SetRegisterAllowed(0x9B0); +SetRegisterAllowed(0x9B4); +SetRegisterAllowed(0x9B8); +SetRegisterAllowed(0x9BC); +SetRegisterAllowed(0x9C0); +SetRegisterAllowed(0x9C4); +SetRegisterAllowed(0x9C8); +SetRegisterAllowed(0x9CC); +SetRegisterAllowed(0x9D0); +SetRegisterAllowed(0x9D4); +SetRegisterAllowed(0x9D8); +SetRegisterAllowed(0x9DC); +SetRegisterAllowed(0x9E0); +SetRegisterAllowed(0x9E4); +SetRegisterAllowed(0x9E8); +SetRegisterAllowed(0x9EC); +SetRegisterAllowed(0x9F0); +SetRegisterAllowed(0x9F4); +SetRegisterAllowed(0x9F8); +SetRegisterAllowed(0x9FC); +SetRegisterAllowed(0xA00); +SetRegisterAllowed(0xA04); +SetRegisterAllowed(0xA08); +SetRegisterAllowed(0xA0C); +SetRegisterAllowed(0xA10); +SetRegisterAllowed(0xA14); +SetRegisterAllowed(0xA18); +SetRegisterAllowed(0xA1C); +SetRegisterAllowed(0xA20); +SetRegisterAllowed(0xA24); +SetRegisterAllowed(0xA28); +SetRegisterAllowed(0xA2C); +SetRegisterAllowed(0xA30); +SetRegisterAllowed(0xA34); +SetRegisterAllowed(0xA38); +SetRegisterAllowed(0xA3C); +SetRegisterAllowed(0xA40); +SetRegisterAllowed(0xA44); +SetRegisterAllowed(0xA48); +SetRegisterAllowed(0xA4C); +SetRegisterAllowed(0xA50); +SetRegisterAllowed(0xA54); +SetRegisterAllowed(0xA58); +SetRegisterAllowed(0xA5C); +SetRegisterAllowed(0xA60); +SetRegisterAllowed(0xA64); +SetRegisterAllowed(0xA68); +SetRegisterAllowed(0xA6C); +SetRegisterAllowed(0xA70); +SetRegisterAllowed(0xA74); +SetRegisterAllowed(0xA78); +SetRegisterAllowed(0xA7C); +SetRegisterAllowed(0xA80); +SetRegisterAllowed(0xA84); +SetRegisterAllowed(0xA88); +SetRegisterAllowed(0xA8C); +SetRegisterAllowed(0xA90); +SetRegisterAllowed(0xA94); +SetRegisterAllowed(0xA98); +SetRegisterAllowed(0xA9C); +SetRegisterAllowed(0xAA0); +SetRegisterAllowed(0xAA4); +SetRegisterAllowed(0xAA8); +SetRegisterAllowed(0xAAC); +SetRegisterAllowed(0xAB0); +SetRegisterAllowed(0xAB4); +SetRegisterAllowed(0xAB8); +SetRegisterAllowed(0xABC); +SetRegisterAllowed(0xAC0); +SetRegisterAllowed(0xAC4); +SetRegisterAllowed(0xAC8); +SetRegisterAllowed(0xACC); +SetRegisterAllowed(0xAD0); +SetRegisterAllowed(0xAD4); +SetRegisterAllowed(0xAD8); +SetRegisterAllowed(0xADC); +SetRegisterAllowed(0xAE0); +SetRegisterAllowed(0xAE4); +SetRegisterAllowed(0xAE8); +SetRegisterAllowed(0xAEC); +SetRegisterAllowed(0xAF0); +SetRegisterAllowed(0xAF4); +SetRegisterAllowed(0xAF8); +SetRegisterAllowed(0xAFC); +SetRegisterAllowed(0xB00); +SetRegisterAllowed(0xB04); +SetRegisterAllowed(0xB08); +SetRegisterAllowed(0xB0C); +SetRegisterAllowed(0xB10); +SetRegisterAllowed(0xB14); +SetRegisterAllowed(0xB18); +SetRegisterAllowed(0xB1C); +SetRegisterAllowed(0xB20); +SetRegisterAllowed(0xB24); +SetRegisterAllowed(0xB28); +SetRegisterAllowed(0xB2C); +SetRegisterAllowed(0xB30); +SetRegisterAllowed(0xB34); +SetRegisterAllowed(0xB38); +SetRegisterAllowed(0xB3C); +SetRegisterAllowed(0xB40); +SetRegisterAllowed(0xB44); +SetRegisterAllowed(0xB48); +SetRegisterAllowed(0xB4C); +SetRegisterAllowed(0xB50); +SetRegisterAllowed(0xB54); +SetRegisterAllowed(0xB58); +SetRegisterAllowed(0xB5C); +SetRegisterAllowed(0xB60); +SetRegisterAllowed(0xB64); +SetRegisterAllowed(0xB68); +SetRegisterAllowed(0xB6C); +SetRegisterAllowed(0xB70); +SetRegisterAllowed(0xB74); +SetRegisterAllowed(0xB78); +SetRegisterAllowed(0xB7C); +SetRegisterAllowed(0xB80); +SetRegisterAllowed(0xB84); +SetRegisterAllowed(0xB88); +SetRegisterAllowed(0xB8C); +SetRegisterAllowed(0xB90); +SetRegisterAllowed(0xB94); +SetRegisterAllowed(0xB98); +SetRegisterAllowed(0xB9C); +SetRegisterAllowed(0xBA0); +SetRegisterAllowed(0xBA4); +SetRegisterAllowed(0xBA8); +SetRegisterAllowed(0xBAC); +SetRegisterAllowed(0xBB0); +SetRegisterAllowed(0xBB4); +SetRegisterAllowed(0xBB8); +SetRegisterAllowed(0xBBC); +SetRegisterAllowed(0xBC0); +SetRegisterAllowed(0xBC4); +SetRegisterAllowed(0xBC8); +SetRegisterAllowed(0xBCC); +SetRegisterAllowed(0xBD0); +SetRegisterAllowed(0xBD4); +SetRegisterAllowed(0xBD8); +SetRegisterAllowed(0xBDC); +SetRegisterAllowed(0xBE0); +SetRegisterAllowed(0xBE4); +SetRegisterAllowed(0xBE8); +SetRegisterAllowed(0xBEC); +SetRegisterAllowed(0xBF0); +SetRegisterAllowed(0xBF4); +SetRegisterAllowed(0xBF8); +SetRegisterAllowed(0xBFC); +SetRegisterAllowed(0xC00); +SetRegisterAllowed(0xC04); +SetRegisterAllowed(0xC08); +SetRegisterAllowed(0xC0C); +SetRegisterAllowed(0xC10); +SetRegisterAllowed(0xC14); +SetRegisterAllowed(0xC18); +SetRegisterAllowed(0xC1C); +SetRegisterAllowed(0xC20); +SetRegisterAllowed(0xC24); +SetRegisterAllowed(0xC28); +SetRegisterAllowed(0xC2C); +SetRegisterAllowed(0xC30); +SetRegisterAllowed(0xC34); +SetRegisterAllowed(0xC38); +SetRegisterAllowed(0xC3C); +SetRegisterAllowed(0xC40); +SetRegisterAllowed(0xC44); +SetRegisterAllowed(0xC48); +SetRegisterAllowed(0xC4C); +SetRegisterAllowed(0xC50); +SetRegisterAllowed(0xC54); +SetRegisterAllowed(0xC58); +SetRegisterAllowed(0xC5C); +SetRegisterAllowed(0xC60); +SetRegisterAllowed(0xC64); +SetRegisterAllowed(0xC68); +SetRegisterAllowed(0xC6C); +SetRegisterAllowed(0xC70); +SetRegisterAllowed(0xC74); +SetRegisterAllowed(0xC78); +SetRegisterAllowed(0xC7C); +SetRegisterAllowed(0xC80); +SetRegisterAllowed(0xC84); +SetRegisterAllowed(0xC88); +SetRegisterAllowed(0xC8C); +SetRegisterAllowed(0xC90); +SetRegisterAllowed(0xC94); +SetRegisterAllowed(0xC98); +SetRegisterAllowed(0xC9C); +SetRegisterAllowed(0xCA0); +SetRegisterAllowed(0xCA4); +SetRegisterAllowed(0xCA8); +SetRegisterAllowed(0xCAC); +SetRegisterAllowed(0xCB0); +SetRegisterAllowed(0xCB4); +SetRegisterAllowed(0xCB8); +SetRegisterAllowed(0xCBC); +SetRegisterAllowed(0xCC0); +SetRegisterAllowed(0xCC4); +SetRegisterAllowed(0xCC8); +SetRegisterAllowed(0xCCC); +SetRegisterAllowed(0xCD0); +SetRegisterAllowed(0xCD4); +SetRegisterAllowed(0xCD8); +SetRegisterAllowed(0xCDC); +SetRegisterAllowed(0xCE0); +SetRegisterAllowed(0xCE4); +SetRegisterAllowed(0xCE8); +SetRegisterAllowed(0xCEC); +SetRegisterAllowed(0xCF0); +SetRegisterAllowed(0xCF4); +SetRegisterAllowed(0xCF8); +SetRegisterAllowed(0xCFC); +SetRegisterAllowed(0xD00); +SetRegisterAllowed(0xD04); +SetRegisterAllowed(0xD08); +SetRegisterAllowed(0xD0C); +SetRegisterAllowed(0xD10); +SetRegisterAllowed(0xD14); +SetRegisterAllowed(0xD18); +SetRegisterAllowed(0xD1C); +SetRegisterAllowed(0xD20); +SetRegisterAllowed(0xD24); +SetRegisterAllowed(0xD28); +SetRegisterAllowed(0xD2C); +SetRegisterAllowed(0xD30); +SetRegisterAllowed(0xD34); +SetRegisterAllowed(0xD38); +SetRegisterAllowed(0xD3C); +SetRegisterAllowed(0xD40); +SetRegisterAllowed(0xD44); +SetRegisterAllowed(0xD48); +SetRegisterAllowed(0xD4C); +SetRegisterAllowed(0xD50); +SetRegisterAllowed(0xD54); +SetRegisterAllowed(0xD58); +SetRegisterAllowed(0xD5C); +SetRegisterAllowed(0xD60); +SetRegisterAllowed(0xD64); +SetRegisterAllowed(0xD68); +SetRegisterAllowed(0xD6C); +SetRegisterAllowed(0xD70); +SetRegisterAllowed(0xD74); +SetRegisterAllowed(0xD78); +SetRegisterAllowed(0xD7C); +SetRegisterAllowed(0xD80); +SetRegisterAllowed(0xD84); +SetRegisterAllowed(0xD88); +SetRegisterAllowed(0xD8C); +SetRegisterAllowed(0xD90); +SetRegisterAllowed(0xD94); +SetRegisterAllowed(0xD98); +SetRegisterAllowed(0xD9C); +SetRegisterAllowed(0xDA0); +SetRegisterAllowed(0xDA4); +SetRegisterAllowed(0xDA8); +SetRegisterAllowed(0xDAC); +SetRegisterAllowed(0xDB0); +SetRegisterAllowed(0xDB4); +SetRegisterAllowed(0xDB8); +SetRegisterAllowed(0xDBC); +SetRegisterAllowed(0xDC0); +SetRegisterAllowed(0xDC4); +SetRegisterAllowed(0xDC8); +SetRegisterAllowed(0xDCC); +SetRegisterAllowed(0xDD0); +SetRegisterAllowed(0xDD4); +SetRegisterAllowed(0xDD8); +SetRegisterAllowed(0xDDC); +SetRegisterAllowed(0xDE0); +SetRegisterAllowed(0xDE4); +SetRegisterAllowed(0xDE8); +SetRegisterAllowed(0xDEC); +SetRegisterAllowed(0xDF0); +SetRegisterAllowed(0xDF4); +SetRegisterAllowed(0xDF8); +SetRegisterAllowed(0xDFC); +SetRegisterAllowed(0xE00); +SetRegisterAllowed(0xE04); +SetRegisterAllowed(0xE08); +SetRegisterAllowed(0xE0C); +SetRegisterAllowed(0xE10); +SetRegisterAllowed(0xE14); +SetRegisterAllowed(0xE18); +SetRegisterAllowed(0xE1C); +SetRegisterAllowed(0xE20); +SetRegisterAllowed(0xE24); +SetRegisterAllowed(0xE28); +SetRegisterAllowed(0xE2C); +SetRegisterAllowed(0xE30); +SetRegisterAllowed(0xE34); +SetRegisterAllowed(0xE38); +SetRegisterAllowed(0xE3C); +SetRegisterAllowed(0xE40); +SetRegisterAllowed(0xE44); +SetRegisterAllowed(0xE48); +SetRegisterAllowed(0xE4C); +SetRegisterAllowed(0xE50); +SetRegisterAllowed(0xE54); +SetRegisterAllowed(0xE58); +SetRegisterAllowed(0xE5C); +SetRegisterAllowed(0xE60); +SetRegisterAllowed(0xE64); +SetRegisterAllowed(0xE68); +SetRegisterAllowed(0xE6C); +SetRegisterAllowed(0xE70); +SetRegisterAllowed(0xE74); +SetRegisterAllowed(0xE78); +SetRegisterAllowed(0xE7C); +SetRegisterAllowed(0xE80); +SetRegisterAllowed(0xE84); +SetRegisterAllowed(0xE88); +SetRegisterAllowed(0xE8C); +SetRegisterAllowed(0xE90); +SetRegisterAllowed(0xE94); +SetRegisterAllowed(0xE98); +SetRegisterAllowed(0xE9C); +SetRegisterAllowed(0xEA0); +SetRegisterAllowed(0xEA4); +SetRegisterAllowed(0xEA8); +SetRegisterAllowed(0xEAC); +SetRegisterAllowed(0xEB0); +SetRegisterAllowed(0xEB4); +SetRegisterAllowed(0xEB8); +SetRegisterAllowed(0xEBC); +SetRegisterAllowed(0xEC0); +SetRegisterAllowed(0xEC4); +SetRegisterAllowed(0xEC8); +SetRegisterAllowed(0xECC); +SetRegisterAllowed(0xED0); +SetRegisterAllowed(0xED4); +SetRegisterAllowed(0xED8); diff --git a/Source/Atmosphere-Patches/secmon_memory_layout.hpp b/Source/Atmosphere-Patches/secmon_memory_layout.hpp new file mode 100644 index 00000000..891d9d98 --- /dev/null +++ b/Source/Atmosphere-Patches/secmon_memory_layout.hpp @@ -0,0 +1,348 @@ +/* + * Copyright (c) Atmosphère-NX + * + * 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 . + */ +#pragma once +#include +#include + +namespace ams::secmon { + + using Address = u64; + + struct MemoryRegion { + private: + Address m_start_address; + Address m_end_address; + public: + consteval MemoryRegion(Address address, size_t size) : m_start_address(address), m_end_address(address + size) { + if (m_end_address < m_start_address) { + __builtin_unreachable(); + } + } + + constexpr Address GetStartAddress() const { + return m_start_address; + } + + constexpr Address GetAddress() const { + return this->GetStartAddress(); + } + + constexpr Address GetEndAddress() const { + return m_end_address; + } + + constexpr Address GetLastAddress() const { + return m_end_address - 1; + } + + constexpr size_t GetSize() const { + return m_end_address - m_start_address; + } + + constexpr bool Contains(Address address, size_t size) const { + return m_start_address <= address && (address + size - 1) <= this->GetLastAddress(); + } + + constexpr bool Contains(const MemoryRegion &rhs) const { + return this->Contains(rhs.GetStartAddress(), rhs.GetSize()); + } + + template requires (std::is_same::value || util::is_pod::value) + ALWAYS_INLINE T *GetPointer() const { + return reinterpret_cast(this->GetAddress()); + } + + template requires (std::is_same::value || util::is_pod::value) + ALWAYS_INLINE T *GetEndPointer() const { + return reinterpret_cast(this->GetEndAddress()); + } + }; + + constexpr inline const MemoryRegion MemoryRegionVirtual = MemoryRegion(UINT64_C(0x1F0000000), 2_MB); + constexpr inline const MemoryRegion MemoryRegionPhysical = MemoryRegion(UINT64_C( 0x40000000), 1_GB); + constexpr inline const MemoryRegion MemoryRegionDram = MemoryRegion(UINT64_C( 0x80000000), 2_GB); + constexpr inline const MemoryRegion MemoryRegionDramHigh = MemoryRegion(MemoryRegionDram.GetEndAddress(), 2_GB); + + constexpr inline const MemoryRegion MemoryRegionDramForMarikoProgram = MemoryRegion(UINT64_C(0xC0000000), 1_GB); + constexpr inline const MemoryRegion MemoryRegionDramDcFramebuffer = MemoryRegion(UINT64_C(0xC0000000), 4_MB); + static_assert(MemoryRegionDram.Contains(MemoryRegionDramForMarikoProgram)); + static_assert(MemoryRegionDramForMarikoProgram.Contains(MemoryRegionDramDcFramebuffer)); + + constexpr inline const MemoryRegion MemoryRegionDramGpuCarveout = MemoryRegion(UINT64_C(0x80020000), UINT64_C(0x40000)); + static_assert(MemoryRegionDram.Contains(MemoryRegionDramGpuCarveout)); + + constexpr inline const MemoryRegion MemoryRegionDramDefaultKernelCarveout = MemoryRegion(UINT64_C(0x80060000), UINT64_C(0x1FFE0000)); + static_assert(MemoryRegionDram.Contains(MemoryRegionDramDefaultKernelCarveout)); + + constexpr inline const MemoryRegion MemoryRegionDramPackage2Payloads = MemoryRegion(MemoryRegionDram.GetAddress(), 8_MB); + static_assert(MemoryRegionDram.Contains(MemoryRegionDramPackage2Payloads)); + + constexpr inline const MemoryRegion MemoryRegionDramPackage2 = MemoryRegion(UINT64_C(0xA9800000), UINT64_C(0x07FC0000)); + static_assert(MemoryRegionDram.Contains(MemoryRegionDramPackage2)); + + constexpr inline const MemoryRegion MemoryRegionPhysicalIram = MemoryRegion(UINT64_C(0x40000000), 0x40000); + constexpr inline const MemoryRegion MemoryRegionPhysicalTzram = MemoryRegion(UINT64_C(0x7C010000), 0x10000); + constexpr inline const MemoryRegion MemoryRegionPhysicalTzramMariko = MemoryRegion(UINT64_C(0x7C010000), 0x40000); + static_assert(MemoryRegionPhysical.Contains(MemoryRegionPhysicalIram)); + static_assert(MemoryRegionPhysical.Contains(MemoryRegionPhysicalTzram)); + static_assert(MemoryRegionPhysicalTzramMariko.Contains(MemoryRegionPhysicalTzram)); + + constexpr inline const MemoryRegion MemoryRegionPhysicalTzramVolatile(UINT64_C(0x7C010000), 0x2000); + static_assert(MemoryRegionPhysicalTzram.Contains(MemoryRegionPhysicalTzramVolatile)); + + constexpr inline const MemoryRegion MemoryRegionPhysicalTzramNonVolatile(UINT64_C(0x7C012000), 0xE000); + static_assert(MemoryRegionPhysicalTzram.Contains(MemoryRegionPhysicalTzramNonVolatile)); + + static_assert(MemoryRegionPhysicalTzram.GetSize() == MemoryRegionPhysicalTzramNonVolatile.GetSize() + MemoryRegionPhysicalTzramVolatile.GetSize()); + + constexpr inline const MemoryRegion MemoryRegionVirtualL1 = MemoryRegion(util::AlignDown(MemoryRegionVirtual.GetAddress(), mmu::L1EntrySize), mmu::L1EntrySize); + constexpr inline const MemoryRegion MemoryRegionPhysicalL1 = MemoryRegion(util::AlignDown(MemoryRegionPhysical.GetAddress(), mmu::L1EntrySize), mmu::L1EntrySize); + static_assert(MemoryRegionVirtualL1.Contains(MemoryRegionVirtual)); + static_assert(MemoryRegionPhysicalL1.Contains(MemoryRegionPhysical)); + + constexpr inline const MemoryRegion MemoryRegionVirtualL2 = MemoryRegion(util::AlignDown(MemoryRegionVirtual.GetAddress(), mmu::L2EntrySize), mmu::L2EntrySize); + constexpr inline const MemoryRegion MemoryRegionPhysicalIramL2 = MemoryRegion(util::AlignDown(MemoryRegionPhysicalIram.GetAddress(), mmu::L2EntrySize), mmu::L2EntrySize); + constexpr inline const MemoryRegion MemoryRegionPhysicalTzramL2 = MemoryRegion(util::AlignDown(MemoryRegionPhysicalTzram.GetAddress(), mmu::L2EntrySize), mmu::L2EntrySize); + static_assert(MemoryRegionVirtualL2.Contains(MemoryRegionVirtual)); + static_assert(MemoryRegionPhysicalIramL2.Contains(MemoryRegionPhysicalIram)); + static_assert(MemoryRegionPhysicalTzramL2.Contains(MemoryRegionPhysicalTzram)); + + constexpr inline const MemoryRegion MemoryRegionPhysicalIramBootCode = MemoryRegion(UINT64_C(0x40020000), 0x20000); + static_assert(MemoryRegionPhysicalIram.Contains(MemoryRegionPhysicalIramBootCode)); + + constexpr inline const MemoryRegion MemoryRegionVirtualDevice = MemoryRegion(UINT64_C(0x1F0040000), UINT64_C(0x40000)); + static_assert(MemoryRegionVirtual.Contains(MemoryRegionVirtualDevice)); + + constexpr inline const MemoryRegion MemoryRegionVirtualDeviceEmpty = MemoryRegion(MemoryRegionVirtualDevice.GetStartAddress(), 0); + + #define AMS_SECMON_FOREACH_DEVICE_REGION(HANDLER, ...) \ + HANDLER(GicDistributor, Empty, UINT64_C(0x50041000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(GicCpuInterface, GicDistributor, UINT64_C(0x50042000), UINT64_C(0x2000), true, ## __VA_ARGS__) \ + HANDLER(Uart, GicCpuInterface, UINT64_C(0x70006000), UINT64_C(0x1000), false, ## __VA_ARGS__) \ + HANDLER(ClkRst, Uart, UINT64_C(0x60006000), UINT64_C(0x1000), false, ## __VA_ARGS__) \ + HANDLER(RtcPmc, ClkRst, UINT64_C(0x7000E000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(Timer, RtcPmc, UINT64_C(0x60005000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(System, Timer, UINT64_C(0x6000C000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(SecurityEngine, System, UINT64_C(0x70012000), UINT64_C(0x2000), true, ## __VA_ARGS__) \ + HANDLER(SecurityEngine2, SecurityEngine, UINT64_C(0x70412000), UINT64_C(0x2000), true, ## __VA_ARGS__) \ + HANDLER(SysCtr0, SecurityEngine2, UINT64_C(0x700F0000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(MemoryController, SysCtr0, UINT64_C(0x70019000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(ExternalMemoryController, MemoryController, UINT64_C(0x7001b000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(FuseKFuse, ExternalMemoryController, UINT64_C(0x7000F000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(ApbMisc, FuseKFuse, UINT64_C(0x70000000), UINT64_C(0x4000), true, ## __VA_ARGS__) \ + HANDLER(FlowController, ApbMisc, UINT64_C(0x60007000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(BootloaderParams, FlowController, UINT64_C(0x40000000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(I2c5, BootloaderParams, UINT64_C(0x7000D000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(Gpio, I2c5, UINT64_C(0x6000D000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(I2c1, Gpio, UINT64_C(0x7000C000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(ExceptionVectors, I2c1, UINT64_C(0x6000F000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(MemoryController0, ExceptionVectors, UINT64_C(0x7001C000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(MemoryController1, MemoryController0, UINT64_C(0x7001D000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(Sdmmc, MemoryController1, UINT64_C(0x700B0000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(Disp1, Sdmmc, UINT64_C(0x54200000), UINT64_C(0x3000), true, ## __VA_ARGS__) \ + HANDLER(Dsi, Disp1, UINT64_C(0x54300000), UINT64_C(0x1000), true, ## __VA_ARGS__) \ + HANDLER(MipiCal, Dsi, UINT64_C(0x700E3000), UINT64_C(0x1000), true, ## __VA_ARGS__) + + #define DEFINE_DEVICE_REGION(_NAME_, _PREV_, _ADDRESS_, _SIZE_, _SECURE_) \ + constexpr inline const MemoryRegion MemoryRegionVirtualDevice##_NAME_ = MemoryRegion(MemoryRegionVirtualDevice##_PREV_.GetEndAddress() + 0x1000, _SIZE_); \ + constexpr inline const MemoryRegion MemoryRegionPhysicalDevice##_NAME_ = MemoryRegion(_ADDRESS_, _SIZE_); \ + static_assert(MemoryRegionVirtualDevice.Contains(MemoryRegionVirtualDevice##_NAME_)); \ + static_assert(MemoryRegionPhysical.Contains(MemoryRegionPhysicalDevice##_NAME_)); + + AMS_SECMON_FOREACH_DEVICE_REGION(DEFINE_DEVICE_REGION) + + #undef DEFINE_DEVICE_REGION + + constexpr inline const MemoryRegion MemoryRegionVirtualDeviceFuses = MemoryRegion(MemoryRegionVirtualDeviceFuseKFuse.GetAddress() + 0x800, 0x400); + constexpr inline const MemoryRegion MemoryRegionPhysicalDeviceFuses = MemoryRegion(MemoryRegionPhysicalDeviceFuseKFuse.GetAddress() + 0x800, 0x400); + static_assert(MemoryRegionVirtualDeviceFuseKFuse.Contains(MemoryRegionVirtualDeviceFuses)); + static_assert(MemoryRegionPhysicalDeviceFuseKFuse.Contains(MemoryRegionPhysicalDeviceFuses)); + + constexpr inline const MemoryRegion MemoryRegionVirtualDeviceActivityMonitor = MemoryRegion(MemoryRegionVirtualDeviceSystem.GetAddress() + 0x800, 0x400); + constexpr inline const MemoryRegion MemoryRegionPhysicalDeviceActivityMonitor = MemoryRegion(MemoryRegionPhysicalDeviceSystem.GetAddress() + 0x800, 0x400); + static_assert(MemoryRegionVirtualDeviceSystem.Contains(MemoryRegionVirtualDeviceActivityMonitor)); + static_assert(MemoryRegionPhysicalDeviceSystem.Contains(MemoryRegionPhysicalDeviceActivityMonitor)); + + constexpr inline const MemoryRegion MemoryRegionVirtualDeviceUartA = MemoryRegion(MemoryRegionVirtualDeviceUart.GetAddress() + 0x000, 0x040); + constexpr inline const MemoryRegion MemoryRegionVirtualDeviceUartB = MemoryRegion(MemoryRegionVirtualDeviceUart.GetAddress() + 0x040, 0x040); + constexpr inline const MemoryRegion MemoryRegionVirtualDeviceUartC = MemoryRegion(MemoryRegionVirtualDeviceUart.GetAddress() + 0x200, 0x100); + static_assert(MemoryRegionVirtualDeviceUart.Contains(MemoryRegionVirtualDeviceUartA)); + static_assert(MemoryRegionVirtualDeviceUart.Contains(MemoryRegionVirtualDeviceUartB)); + static_assert(MemoryRegionVirtualDeviceUart.Contains(MemoryRegionVirtualDeviceUartC)); + + constexpr inline const MemoryRegion MemoryRegionPhysicalDeviceUartA = MemoryRegion(MemoryRegionPhysicalDeviceUart.GetAddress() + 0x000, 0x040); + constexpr inline const MemoryRegion MemoryRegionPhysicalDeviceUartB = MemoryRegion(MemoryRegionPhysicalDeviceUart.GetAddress() + 0x040, 0x040); + constexpr inline const MemoryRegion MemoryRegionPhysicalDeviceUartC = MemoryRegion(MemoryRegionPhysicalDeviceUart.GetAddress() + 0x200, 0x100); + static_assert(MemoryRegionPhysicalDeviceUart.Contains(MemoryRegionPhysicalDeviceUartA)); + static_assert(MemoryRegionPhysicalDeviceUart.Contains(MemoryRegionPhysicalDeviceUartB)); + static_assert(MemoryRegionPhysicalDeviceUart.Contains(MemoryRegionPhysicalDeviceUartC)); + + constexpr inline const MemoryRegion MemoryRegionVirtualDevicePmc = MemoryRegion(MemoryRegionVirtualDeviceRtcPmc.GetAddress() + 0x400, 0xC00); + constexpr inline const MemoryRegion MemoryRegionPhysicalDevicePmc = MemoryRegion(MemoryRegionPhysicalDeviceRtcPmc.GetAddress() + 0x400, 0xC00); + static_assert(MemoryRegionVirtualDeviceRtcPmc.Contains(MemoryRegionVirtualDevicePmc)); + static_assert(MemoryRegionPhysicalDeviceRtcPmc.Contains(MemoryRegionPhysicalDevicePmc)); + + constexpr inline const MemoryRegion MemoryRegionVirtualTzramReadOnlyAlias = MemoryRegion(UINT64_C(0x1F00A0000), MemoryRegionPhysicalTzram.GetSize()); + constexpr inline const MemoryRegion MemoryRegionPhysicalTzramReadOnlyAlias = MemoryRegion(MemoryRegionPhysicalTzram.GetAddress(), MemoryRegionPhysicalTzram.GetSize()); + static_assert(MemoryRegionVirtual.Contains(MemoryRegionVirtualTzramReadOnlyAlias)); + static_assert(MemoryRegionPhysicalTzram.Contains(MemoryRegionPhysicalTzramReadOnlyAlias)); + + constexpr inline const MemoryRegion MemoryRegionVirtualTzramProgram(UINT64_C(0x1F00C0000), 0xC000); + static_assert(MemoryRegionVirtual.Contains(MemoryRegionVirtualTzramProgram)); + + constexpr inline const MemoryRegion MemoryRegionVirtualTzramProgramExceptionVectors(UINT64_C(0x1F00C0000), 0x800); + static_assert(MemoryRegionVirtualTzramProgram.Contains(MemoryRegionVirtualTzramProgramExceptionVectors)); + + constexpr inline const MemoryRegion MemoryRegionVirtualTzramMarikoProgram(UINT64_C(0x1F00D0000), 0x20000); + constexpr inline const MemoryRegion MemoryRegionPhysicalTzramMarikoProgram(UINT64_C(0x7C020000), 0x20000); + static_assert(MemoryRegionPhysicalTzramMariko.Contains(MemoryRegionPhysicalTzramMarikoProgram)); + + constexpr inline const MemoryRegion MemoryRegionVirtualTzramMarikoProgramFatalErrorContext(UINT64_C(0x1F00EF000), 0x1000); + static_assert(MemoryRegionVirtualTzramMarikoProgram.Contains(MemoryRegionVirtualTzramMarikoProgramFatalErrorContext)); + + constexpr inline const MemoryRegion MemoryRegionPhysicalIramFatalErrorContext(UINT64_C(0x4003E000), 0x1000); + static_assert(MemoryRegionPhysicalIram.Contains(MemoryRegionPhysicalIramFatalErrorContext)); + + constexpr inline const MemoryRegion MemoryRegionVirtualTzramMarikoProgramStack(UINT64_C(0x1F00F4000), 0x8000); + constexpr inline const MemoryRegion MemoryRegionPhysicalTzramMarikoProgramStack(UINT64_C(0x7C040000), 0x8000); + static_assert(MemoryRegionPhysicalTzramMariko.Contains(MemoryRegionPhysicalTzramMarikoProgramStack)); + + constexpr inline const MemoryRegion MemoryRegionPhysicalMarikoProgramImage(UINT64_C(0x80020000), 0x20000); + static_assert(MemoryRegionDram.Contains(MemoryRegionPhysicalMarikoProgramImage)); + + constexpr inline const MemoryRegion MemoryRegionVirtualTzramProgramMain(UINT64_C(0x1F00C0800), 0xB800); + static_assert(MemoryRegionVirtualTzramProgram.Contains(MemoryRegionVirtualTzramProgramMain)); + + static_assert(MemoryRegionVirtualTzramProgram.GetSize() == MemoryRegionVirtualTzramProgramExceptionVectors.GetSize() + MemoryRegionVirtualTzramProgramMain.GetSize()); + + constexpr inline const MemoryRegion MemoryRegionPhysicalTzramProgram(UINT64_C(0x7C012000), 0xC000); + static_assert(MemoryRegionPhysicalTzramNonVolatile.Contains(MemoryRegionPhysicalTzramProgram)); + + constexpr inline const Address PhysicalTzramProgramResetVector = MemoryRegionPhysicalTzramProgram.GetAddress() + MemoryRegionVirtualTzramProgramExceptionVectors.GetSize(); + static_assert(static_cast(PhysicalTzramProgramResetVector) == PhysicalTzramProgramResetVector); + + constexpr uintptr_t GetPhysicalTzramProgramAddress(uintptr_t virtual_address) { + return virtual_address - MemoryRegionVirtualTzramProgram.GetStartAddress() + MemoryRegionPhysicalTzramNonVolatile.GetStartAddress(); + } + + constexpr inline const MemoryRegion MemoryRegionVirtualIramSc7Work = MemoryRegion(UINT64_C(0x1F0120000), MemoryRegionPhysicalTzram.GetSize()); + constexpr inline const MemoryRegion MemoryRegionPhysicalIramSc7Work = MemoryRegion( UINT64_C(0x40020000), MemoryRegionPhysicalTzram.GetSize()); + static_assert(MemoryRegionVirtual.Contains(MemoryRegionVirtualIramSc7Work)); + static_assert(MemoryRegionPhysicalIram.Contains(MemoryRegionPhysicalIramSc7Work)); + + constexpr inline const MemoryRegion MemoryRegionVirtualIramSc7Firmware = MemoryRegion(UINT64_C(0x1F0140000), 0x1000); + constexpr inline const MemoryRegion MemoryRegionPhysicalIramSc7Firmware = MemoryRegion( UINT64_C(0x40003000), 0x1000); + static_assert(MemoryRegionVirtual.Contains(MemoryRegionVirtualIramSc7Firmware)); + static_assert(MemoryRegionPhysicalIram.Contains(MemoryRegionPhysicalIramSc7Firmware)); + + constexpr inline const MemoryRegion MemoryRegionPhysicalIramSecureMonitorDebug(UINT64_C(0x40034000), 0x4000); + static_assert(MemoryRegionPhysicalIram.Contains(MemoryRegionPhysicalIramSecureMonitorDebug)); + + constexpr inline const MemoryRegion MemoryRegionVirtualDebugCode = MemoryRegion(UINT64_C(0x1F0150000), 0x4000); + constexpr inline const MemoryRegion MemoryRegionPhysicalDebugCode = MemoryRegion(UINT64_C(0x40034000), 0x4000); + static_assert(MemoryRegionPhysicalIramSecureMonitorDebug.Contains(MemoryRegionPhysicalDebugCode)); + + constexpr inline const MemoryRegion MemoryRegionVirtualDebug = MemoryRegion(UINT64_C(0x1F0160000), 0x10000); + static_assert(MemoryRegionVirtual.Contains(MemoryRegionVirtualDebug)); + + constexpr inline const MemoryRegion MemoryRegionVirtualTzramBootCode = MemoryRegion(UINT64_C(0x1F01C0000), 0x2000); + constexpr inline const MemoryRegion MemoryRegionPhysicalTzramBootCode = MemoryRegion( UINT64_C(0x7C010000), 0x2000); + static_assert(MemoryRegionVirtual.Contains(MemoryRegionVirtualTzramBootCode)); + static_assert(MemoryRegionPhysicalTzramVolatile.Contains(MemoryRegionPhysicalTzramBootCode)); + + constexpr inline const MemoryRegion MemoryRegionPhysicalDramMonitorConfiguration = MemoryRegion( UINT64_C(0x8000F000), 0x1000); + + constexpr inline const MemoryRegion MemoryRegionVirtualDramSecureDataStore = MemoryRegion(UINT64_C(0x1F0100000), 0x10000); + constexpr inline const MemoryRegion MemoryRegionPhysicalDramSecureDataStore = MemoryRegion( UINT64_C(0x80010000), 0x10000); + static_assert(MemoryRegionVirtual.Contains(MemoryRegionVirtualDramSecureDataStore)); + static_assert(MemoryRegionDram.Contains(MemoryRegionPhysicalDramSecureDataStore)); + + constexpr inline const MemoryRegion MemoryRegionVirtualDramDebugDataStore = MemoryRegion(UINT64_C(0x1F0110000), 0x4000); + constexpr inline const MemoryRegion MemoryRegionPhysicalDramDebugDataStore = MemoryRegion( UINT64_C(0x8000C000), 0x4000); + static_assert(MemoryRegionVirtual.Contains(MemoryRegionVirtualDramSecureDataStore)); + static_assert(MemoryRegionDram.Contains(MemoryRegionPhysicalDramSecureDataStore)); + + constexpr inline const MemoryRegion MemoryRegionVirtualDramSdmmcMappedData = MemoryRegion(UINT64_C(0x1F0100000), 0xC000); + constexpr inline const MemoryRegion MemoryRegionPhysicalDramSdmmcMappedData = MemoryRegion(UINT64_C(0x80010000), 0xC000); + + constexpr inline const MemoryRegion MemoryRegionVirtualDramDcL0DevicePageTable = MemoryRegion(UINT64_C(0x1F010C000), 0x1000); + constexpr inline const MemoryRegion MemoryRegionPhysicalDramDcL0DevicePageTable = MemoryRegion( UINT64_C(0x8001C000), 0x1000); + + constexpr inline const MemoryRegion MemoryRegionVirtualDramSdmmc1L0DevicePageTable = MemoryRegion(UINT64_C(0x1F010E000), 0x1000); + constexpr inline const MemoryRegion MemoryRegionPhysicalDramSdmmc1L0DevicePageTable = MemoryRegion( UINT64_C(0x8001E000), 0x1000); + + constexpr inline const MemoryRegion MemoryRegionVirtualDramSdmmc1L1DevicePageTable = MemoryRegion(UINT64_C(0x1F010F000), 0x1000); + constexpr inline const MemoryRegion MemoryRegionPhysicalDramSdmmc1L1DevicePageTable = MemoryRegion( UINT64_C(0x8001F000), 0x1000); + + constexpr inline const MemoryRegion MemoryRegionVirtualDramSecureDataStoreTzram = MemoryRegion(UINT64_C(0x1F0100000), 0xE000); + constexpr inline const MemoryRegion MemoryRegionVirtualDramSecureDataStoreWarmbootFirmware = MemoryRegion(UINT64_C(0x1F010E000), 0x17C0); + constexpr inline const MemoryRegion MemoryRegionVirtualDramSecureDataStoreSecurityEngineState = MemoryRegion(UINT64_C(0x1F010F7C0), 0x0840); + static_assert(MemoryRegionVirtualDramSecureDataStore.Contains(MemoryRegionVirtualDramSecureDataStoreTzram)); + static_assert(MemoryRegionVirtualDramSecureDataStore.Contains(MemoryRegionVirtualDramSecureDataStoreWarmbootFirmware)); + static_assert(MemoryRegionVirtualDramSecureDataStore.Contains(MemoryRegionVirtualDramSecureDataStoreSecurityEngineState)); + + constexpr inline const MemoryRegion MemoryRegionPhysicalDramSecureDataStoreTzram = MemoryRegion(UINT64_C(0x80010000), 0xE000); + constexpr inline const MemoryRegion MemoryRegionPhysicalDramSecureDataStoreWarmbootFirmware = MemoryRegion(UINT64_C(0x8001E000), 0x17C0); + constexpr inline const MemoryRegion MemoryRegionPhysicalDramSecureDataStoreSecurityEngineState = MemoryRegion(UINT64_C(0x8001F7C0), 0x0840); + static_assert(MemoryRegionPhysicalDramSecureDataStore.Contains(MemoryRegionPhysicalDramSecureDataStoreTzram)); + static_assert(MemoryRegionPhysicalDramSecureDataStore.Contains(MemoryRegionPhysicalDramSecureDataStoreWarmbootFirmware)); + static_assert(MemoryRegionPhysicalDramSecureDataStore.Contains(MemoryRegionPhysicalDramSecureDataStoreSecurityEngineState)); + + constexpr inline const MemoryRegion MemoryRegionVirtualAtmosphereIramPage = MemoryRegion(UINT64_C(0x1F01F0000), 0x1000); + static_assert(MemoryRegionVirtual.Contains(MemoryRegionVirtualAtmosphereIramPage)); + + constexpr inline const MemoryRegion MemoryRegionVirtualAtmosphereUserPage = MemoryRegion(UINT64_C(0x1F01F2000), 0x1000); + static_assert(MemoryRegionVirtual.Contains(MemoryRegionVirtualAtmosphereUserPage)); + + constexpr inline const MemoryRegion MemoryRegionVirtualSmcUserPage = MemoryRegion(UINT64_C(0x1F01F4000), 0x1000); + static_assert(MemoryRegionVirtual.Contains(MemoryRegionVirtualSmcUserPage)); + + constexpr inline const MemoryRegion MemoryRegionVirtualTzramVolatileData = MemoryRegion(UINT64_C(0x1F01F6000), 0x1000); + constexpr inline const MemoryRegion MemoryRegionPhysicalTzramVolatileData = MemoryRegion( UINT64_C(0x7C010000), 0x1000); + static_assert(MemoryRegionVirtual.Contains(MemoryRegionVirtualTzramVolatileData)); + static_assert(MemoryRegionPhysicalTzramVolatile.Contains(MemoryRegionPhysicalTzramVolatileData)); + + constexpr inline const MemoryRegion MemoryRegionVirtualTzramVolatileStack = MemoryRegion(UINT64_C(0x1F01F8000), 0x1000); + constexpr inline const MemoryRegion MemoryRegionPhysicalTzramVolatileStack = MemoryRegion( UINT64_C(0x7C011000), 0x1000); + static_assert(MemoryRegionVirtual.Contains(MemoryRegionVirtualTzramVolatileStack)); + static_assert(MemoryRegionPhysicalTzramVolatile.Contains(MemoryRegionPhysicalTzramVolatileStack)); + + constexpr inline const MemoryRegion MemoryRegionVirtualTzramConfigurationData = MemoryRegion(UINT64_C(0x1F01FA000), 0x1000); + constexpr inline const MemoryRegion MemoryRegionPhysicalTzramConfigurationData = MemoryRegion( UINT64_C(0x7C01E000), 0x1000); + static_assert(MemoryRegionVirtual.Contains(MemoryRegionVirtualTzramConfigurationData)); + static_assert(MemoryRegionPhysicalTzramNonVolatile.Contains(MemoryRegionPhysicalTzramConfigurationData)); + + constexpr inline const MemoryRegion MemoryRegionVirtualTzramL1PageTable = MemoryRegion(UINT64_C(0x1F01FCFC0), 0x40); + constexpr inline const MemoryRegion MemoryRegionPhysicalTzramL1PageTable = MemoryRegion( UINT64_C(0x7C01EFC0), 0x40); + static_assert(MemoryRegionPhysicalTzramConfigurationData.Contains(MemoryRegionPhysicalTzramL1PageTable)); + + constexpr inline const MemoryRegion MemoryRegionVirtualTzramL2L3PageTable = MemoryRegion(UINT64_C(0x1F01FE000), 0x1000); + constexpr inline const MemoryRegion MemoryRegionPhysicalTzramL2L3PageTable = MemoryRegion( UINT64_C(0x7C01F000), 0x1000); + static_assert(MemoryRegionVirtual.Contains(MemoryRegionVirtualTzramL2L3PageTable)); + static_assert(MemoryRegionPhysicalTzramNonVolatile.Contains(MemoryRegionPhysicalTzramL2L3PageTable)); + + constexpr inline const MemoryRegion MemoryRegionPhysicalTzramFullProgramImage = MemoryRegion(UINT64_C(0x7C010800), 0xD800); + constexpr inline const MemoryRegion MemoryRegionPhysicalIramBootCodeImage = MemoryRegion(UINT64_C(0x40032000), 0xC000); + + constexpr inline const MemoryRegion MemoryRegionPhysicalIramBootCodeCode = MemoryRegion(UINT64_C(0x40032000), 0x1000); + constexpr inline const MemoryRegion MemoryRegionPhysicalIramBootCodeKeys = MemoryRegion(UINT64_C(0x40033000), 0x1000); + + constexpr inline const MemoryRegion MemoryRegionPhysicalIramWarmbootBin = MemoryRegion(UINT64_C(0x4003E000), 0x17F0); + constexpr inline const MemoryRegion MemoryRegionPhysicalIramBootConfig = MemoryRegion(UINT64_C(0x4003F800), 0x400); + + constexpr inline const MemoryRegion MemoryRegionPhysicalIramRebootStub = MemoryRegion(UINT64_C(0x4003F000), 0x1000); + +} diff --git a/Source/Atmosphere-Patches/secmon_smc_register_access.cpp b/Source/Atmosphere-Patches/secmon_smc_register_access.cpp new file mode 100644 index 00000000..eae2933c --- /dev/null +++ b/Source/Atmosphere-Patches/secmon_smc_register_access.cpp @@ -0,0 +1,196 @@ +/* + * Copyright (c) Atmosphère-NX + * + * 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 . + */ +#include +#include "../secmon_error.hpp" +#include "secmon_smc_register_access.hpp" + +namespace ams::secmon::smc { + + namespace { + + template + constexpr void SetRegisterTableAllowed(std::array &arr, uintptr_t reg) { + /* All registers should be four byte aligned. */ + AMS_ASSUME(reg % sizeof(u32) == 0); + + /* Reduce the register to an index. */ + reg /= sizeof(u32); + + /* Get the index and mask. */ + const auto index = reg / BITSIZEOF(u8); + const auto mask = (1u << (reg % BITSIZEOF(u8))); + + /* Check that the permission bit isn't already set. */ + AMS_ASSUME((arr[index] & mask) == 0); + + /* Set the permission bit. */ + arr[index] |= mask; + + /* Ensure that indices are set in sorted order. */ + for (auto i = (reg % BITSIZEOF(u8)) + 1; i < 8; ++i) { + AMS_ASSUME((arr[index] & (1u << i)) == 0); + } + + for (auto i = index + 1; i < arr.size(); ++i) { + AMS_ASSUME(arr[i] == 0); + } + } + + template + consteval std::pair GetReducedAccessTableInfo(const std::array &arr) { + for (int last = arr.size() - 1; last >= 0; --last) { + if (arr[last] != 0) { + const int end = last + 1; + for (int start = 0; start < end; ++start) { + if (arr[start] != 0) { + return std::make_pair(static_cast(start), static_cast(end)); + } + } + return std::make_pair(static_cast(0), static_cast(end)); + } + } + + /* All empty perm table is disallowed. */ + AMS_ASSUME(false); + } + + + template + struct AccessTable { + static constexpr inline auto ReducedAccessTableInfo = GetReducedAccessTableInfo(RawTable); + static constexpr inline size_t ReducedAccessTableSize = ReducedAccessTableInfo.second - ReducedAccessTableInfo.first; + static constexpr inline auto ReducedAccessTable = []() -> std::array { + std::array reduced = {}; + + for (size_t i = ReducedAccessTableInfo.first; i < ReducedAccessTableInfo.second; ++i) { + reduced[i - ReducedAccessTableInfo.first] = RawTable[i]; + } + + return reduced; + }(); + + static constexpr u32 Address = _Address + (ReducedAccessTableInfo.first * sizeof(u32) * BITSIZEOF(u8)); + static constexpr u32 Size = static_cast(ReducedAccessTableSize * sizeof(u32) * BITSIZEOF(u8)); + + static_assert(Size <= 0x1000); + }; + + struct AccessTableEntry { + const u8 * const table; + uintptr_t virtual_address; + u32 address; + u32 size; + }; + + /* Include the access tables. */ + #include "secmon_define_pmc_access_table.inc" + #include "secmon_define_mc_access_table.inc" + #include "secmon_define_emc_access_table.inc" + #include "secmon_define_mc01_access_table.inc" + + constexpr const AccessTableEntry AccessTables[] = { + { PmcAccessTable::ReducedAccessTable.data(), MemoryRegionVirtualDevicePmc.GetAddress(), PmcAccessTable::Address, PmcAccessTable::Size, }, + { McAccessTable::ReducedAccessTable.data(), MemoryRegionVirtualDeviceMemoryController.GetAddress(), McAccessTable::Address, McAccessTable::Size, }, + { EmcAccessTable::ReducedAccessTable.data(), MemoryRegionVirtualDeviceExternalMemoryController.GetAddress(), EmcAccessTable::Address, EmcAccessTable::Size, }, + { Mc01AccessTable::ReducedAccessTable.data(), Mc01AccessTable::Address + MemoryRegionVirtualDeviceMemoryController0.GetAddress(), Mc01AccessTable::Address + MemoryRegionPhysicalDeviceMemoryController0.GetAddress(), Mc01AccessTable::Size, }, + { Mc01AccessTable::ReducedAccessTable.data(), Mc01AccessTable::Address + MemoryRegionVirtualDeviceMemoryController1.GetAddress(), Mc01AccessTable::Address + MemoryRegionPhysicalDeviceMemoryController1.GetAddress(), Mc01AccessTable::Size, }, + }; + + constexpr bool IsAccessAllowed(const AccessTableEntry &entry, uintptr_t address) { + /* Check if the address is within range. */ + if (!(entry.address <= address && address < entry.address + entry.size)) { + return false; + } + + /* Get the offset. */ + const auto offset = address - entry.address; + + /* Convert it to an index. */ + const auto reg_index = offset / sizeof(u32); + + /* Get the bit fields. */ + const auto index = reg_index / BITSIZEOF(u8); + const auto mask = (1u << (reg_index % BITSIZEOF(u8))); + + /* Validate that we're not going out of bounds. */ + if (index >= entry.size / sizeof(u32)) { + return false; + } + + return (entry.table[index] & mask) != 0; + } + + constexpr const AccessTableEntry *GetAccessTableEntry(uintptr_t address) { + for (const auto &entry : AccessTables) { + if (IsAccessAllowed(entry, address)) { + return std::addressof(entry); + } + } + + return nullptr; + } + + } + + SmcResult SmcReadWriteRegister(SmcArguments &args) { + /* Get the arguments. */ + const uintptr_t address = args.r[1]; + const u32 mask = args.r[2]; + const u32 value = args.r[3]; + + /* Validate that the address is aligned. */ + SMC_R_UNLESS(util::IsAligned(address, alignof(u32)), InvalidArgument); + + /* Find the access table. */ + const AccessTableEntry * const entry = GetAccessTableEntry(address); + + /* Translate our entry into an address to access. */ + uintptr_t virtual_address = 0; + if (entry != nullptr) { + /* Get the address to read or write. */ + virtual_address = entry->virtual_address + (address - entry->address); + } else { + /* For no clearly discernable reason, SmcReadWriteRegister returns success despite not doing the read/write */ + /* when accessing the SMMU controls for the BPMP and for APB-DMA. */ + /* This is "probably" to fuck with hackers who got access to the SMC and are trying to get control of the */ + /* BPMP to exploit jamais vu, deja vu, or other related DMA/wake-from-sleep vulnerabilities. */ + constexpr uintptr_t MC = MemoryRegionPhysicalDeviceMemoryController.GetAddress(); + SMC_R_UNLESS((address == (MC + MC_SMMU_AVPC_ASID) || address == (MC + MC_SMMU_PPCS1_ASID)), InvalidArgument); + + /* For backwards compatibility, we'll allow access to these devices on 1.0.0. */ + if (GetTargetFirmware() < TargetFirmware_2_0_0) { + virtual_address = MemoryRegionVirtualDeviceMemoryController.GetAddress() + (address - MC); + } + } + + /* Perform the read or write, if we should. */ + if (virtual_address != 0) { + u32 out = 0; + + if (mask != ~static_cast(0)) { + out = reg::Read(virtual_address); + } + if (mask != static_cast(0)) { + reg::Write(virtual_address, (out & ~mask) | (value & mask)); + } + + args.r[1] = out; + } + + return SmcResult::Success; + } + +} diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/customize.cpp b/Source/Atmosphere/stratosphere/loader/source/oc/customize.cpp index e8bd2c29..8781b4f6 100644 --- a/Source/Atmosphere/stratosphere/loader/source/oc/customize.cpp +++ b/Source/Atmosphere/stratosphere/loader/source/oc/customize.cpp @@ -22,6 +22,7 @@ #define ENABLED 1 #define DISABLED 0 +#define CPU_MAX_MAX_VOLT 1375000 namespace ams::ldr::oc { @@ -36,11 +37,11 @@ volatile CustomizeTable C = { .commonCpuBoostClock = 1785000, // Default boost clock -.commonEmcMemVolt = 1175000, // LPDDR4X JEDEC Specification +.commonEmcMemVolt = 1125000, // LPDDR4X JEDEC Specification .eristaCpuMaxVolt = 1235, -.eristaEmcMaxClock = 1600001, // Maximum HB-MGCH ram rating +.eristaEmcMaxClock = 1862400, // Maximum HB-MGCH ram rating .marikoCpuMaxVolt = 1120, @@ -56,19 +57,11 @@ volatile CustomizeTable C = { .eristaGpuUV = 3, -.enableMarikoGpuUnsafeFreqs = ENABLED, - -.enableEristaGpuUnsafeFreqs = ENABLED, - -.enableMarikoCpuUnsafeFreqs = ENABLED, - -.enableEristaCpuUnsafeFreqs = ENABLED, - .commonGpuVoltOffset = 0, .EmcDvbShift = 5, -// Defaults - (3-3-2) 0-1-4-3-6 +// Defaults - Zeroed // Primary .t1_tRCD = 0, @@ -85,7 +78,7 @@ volatile CustomizeTable C = { .marikoCpuVmin = 600, -.eristaGpuVmin = 775, +.eristaGpuVmin = 810, .marikoGpuVmin = 610, @@ -123,19 +116,32 @@ volatile CustomizeTable C = { .eristaGpuVoltArray = { 750 /* 76 */, + 750 /* 115 */, 750 /* 153 */, + 750 /* 192 */, 750 /* 230 */, - 750 /* 307 */, - 775 /* 384 */, - 800 /* 460 */, - 825 /* 537 */, - 850 /* 614 */, - 875 /* 691 */, - 900 /* 768 */, + 775 /* 269 */, + 775 /* 307 */, + 800 /* 346 */, + 800 /* 384 */, + 825 /* 422 */, + 825 /* 460 */, + 850 /* 499 */, + 850 /* 537 */, + 875 /* 576 */, + 875 /* 614 */, + 900 /* 652 */, + 900 /* 691 */, + 925 /* 729 */, + 925 /* 768 */, + 950 /* 806 */, 950 /* 844 */, - 887 /* 921 */, - 950 /* 998 (Disabled by default) */, - 995 /* 1075 (Disabled by default) */, + 975 /* 883 */, + 975 /* 921 */, + 0 /* 960 (Disabled by default) */, + 0 /* 998 (Disabled by default) */, + 0 /* 1036 (Disabled by default) */, + 0 /* 1075 (Disabled by default) */, }, @@ -160,6 +166,11 @@ volatile CustomizeTable C = { { 1581000, { 1130000 }, { 2889664, -122173, 1834 } }, { 1683000, { 1168000 }, { 5100873, -279186, 4747 } }, { 1785000, { 1227500 }, { 5100873, -279186, 4747 } }, + { 1887000, { CPU_MAX_MAX_VOLT }, { 5100873, -279186, 4747 } }, + { 1963500, { CPU_MAX_MAX_VOLT }, { 5100873, -279186, 4747 } }, + { 2091000, { CPU_MAX_MAX_VOLT }, { 5100873, -279186, 4747 } }, + { 2193000, { CPU_MAX_MAX_VOLT }, { 5100873, -279186, 4747 } }, + { 2295000, { CPU_MAX_MAX_VOLT }, { 5100873, -279186, 4747 } }, }, /* - Mariko CPU DVFS Table: @@ -174,94 +185,141 @@ volatile CustomizeTable C = { { 714000, { 885768, -20215, 27 }, {} }, { 816000, { 929540, -21725, 27 }, {} }, { 918000, { 976958, -23225, 27 }, {} }, - { 1020000, { 1028021, -24725, 27 }, { } }, - { 1122000, { 1082730, -26235, 27 }, { } }, - { 1224000, { 1141084, -27735, 27 }, { } }, - { 1326000, { 1203084, -29245, 27 }, { } }, - { 1428000, { 1268729, -30745, 27 }, { } }, - { 1581000, { 1374032, -33005, 27 }, { } }, - { 1683000, { 1448791, -34505, 27 }, { } }, - { 1785000, { 1527196, -36015, 27 }, { } }, - { 1887000, { 1609246, -37515, 27 }, { } }, - { 1963500, { 1675751, -38635, 27 }, { } }, + { 1020000, { 1028021, -24725, 27 }, { 1120000 } }, + { 1122000, { 1082730, -26235, 27 }, { 1120000 } }, + { 1224000, { 1141084, -27735, 27 }, { 1120000 } }, + { 1326000, { 1203084, -29245, 27 }, { 1120000 } }, + { 1428000, { 1268729, -30745, 27 }, { 1120000 } }, + { 1581000, { 1374032, -33005, 27 }, { 1120000 } }, + { 1683000, { 1448791, -34505, 27 }, { 1120000 } }, + { 1785000, { 1527196, -36015, 27 }, { 1120000 } }, + { 1887000, { 1609246, -37515, 27 }, { 1120000 } }, + { 1963500, { 1675751, -38635, 27 }, { 1120000 } }, + + { 2091000, { 1716501, -39395, 27 }, { CPU_MAX_MAX_VOLT } }, + { 2193000, { 1775132, -40505, 27 }, { CPU_MAX_MAX_VOLT } }, + { 2295000, { 1866287, -42005, 27 }, { CPU_MAX_MAX_VOLT } }, }, .marikoCpuDvfsTableSLT = { - { 204000, { 732856, -17335, 113 }, { } }, - { 306000, { 760024, -18195, 113 }, { } }, - { 408000, { 789258, -19055, 113 }, { } }, - { 510000, { 789258, -19915, 113 }, { } }, + // { 204000, { 732856, -17335, 113 }, { } }, + // { 306000, { 760024, -18195, 113 }, { } }, + // { 408000, { 789258, -19055, 113 }, { } }, + // { 510000, { 789258, -19915, 113 }, { } }, { 612000, { 789258, -19055, 113 }, { } }, { 714000, { 820558, -19915, 113 }, { } }, { 816000, { 853926, -20775, 113 }, { } }, { 918000, { 889361, -21625, 113 }, { } }, - { 1020000, { 926862, -22485, 113 }, { } }, - { 1122000, { 926862, -22485, 113 }, { } }, - { 1224000, { 926862, -22485, 113 }, { } }, - { 1326000, { 966431, -23345, 113 }, { } }, - { 1428000, { 1008066, -24205, 113 }, { } }, - { 1581000, { 1051768, -25065, 113 }, { } }, - { 1683000, { 1097537, -25925, 113 }, { } }, - { 1785000, { 1145373, -26785, 113 }, { } }, - { 1887000, { 1195276, -27645, 113 }, { } }, - { 1963500, { 1274006, -29795, 113 }, { } }, - { 2091000, { 1349076, -33235, 113 }, { } }, - { 2193000, { 1386213, -33235, 113 }, { } }, - { 2295000, { 1445416, -34095, 113 }, { } }, + { 1020000, { 926862, -22485, 113 }, { 1120000 } }, + { 1122000, { 926862, -22485, 113 }, { 1120000 } }, + { 1224000, { 926862, -22485, 113 }, { 1120000 } }, + { 1326000, { 966431, -23345, 113 }, { 1120000 } }, + { 1428000, { 1008066, -24205, 113 }, { 1120000 } }, + { 1581000, { 1051768, -25065, 113 }, { 1120000 } }, + { 1683000, { 1097537, -25925, 113 }, { 1120000 } }, + { 1785000, { 1145373, -26785, 113 }, { 1120000 } }, + { 1887000, { 1195276, -27645, 113 }, { 1120000 } }, + { 1963500, { 1274006, -29795, 113 }, { 1120000 } }, + { 2091000, { 1349076, -33235, 113 }, { CPU_MAX_MAX_VOLT } }, + { 2193000, { 1386213, -33235, 113 }, { CPU_MAX_MAX_VOLT } }, + { 2295000, { 1445416, -34095, 113 }, { CPU_MAX_MAX_VOLT } }, + { 2397000, { 1490873, -34955, 113 }, { CPU_MAX_MAX_VOLT } }, + { 2499000, { 1580725, -35815, 113 }, { CPU_MAX_MAX_VOLT } }, + { 2601000, { 1702903, -36675, 113 }, { CPU_MAX_MAX_VOLT } }, + { 2703000, { 1748360, -37535, 113 }, { CPU_MAX_MAX_VOLT } }, + { 2805000, { 1793817, -38395, 113 }, { CPU_MAX_MAX_VOLT } }, + { 2907000, { 1839274, -39255, 113 }, { CPU_MAX_MAX_VOLT } }, + { 3009000, { 1884731, -40115, 113 }, { CPU_MAX_MAX_VOLT } }, }, /* - Erista GPU DVFS Table: */ .eristaGpuDvfsTable = { { 76800, { }, { 814294, 8144, -940, 808, -21583, 226 } }, + { 115200, { }, { 856185, 8144, -940, 808, -21583, 226 } }, { 153600, { }, { 856185, 8144, -940, 808, -21583, 226 } }, + { 192000, { }, { 898077, 8144, -940, 808, -21583, 226 } }, { 230400, { }, { 898077, 8144, -940, 808, -21583, 226 } }, + { 268800, { }, { 939968, 8144, -940, 808, -21583, 226 } }, { 307200, { }, { 939968, 8144, -940, 808, -21583, 226 } }, + { 345600, { }, { 981860, 8144, -940, 808, -21583, 226 } }, { 384000, { }, { 981860, 8144, -940, 808, -21583, 226 } }, + { 422400, { }, { 1023751, 8144, -940, 808, -21583, 226 } }, { 460800, { }, { 1023751, 8144, -940, 808, -21583, 226 } }, + { 499200, { }, { 1065642, 8144, -940, 808, -21583, 226 } }, { 537600, { }, { 1065642, 8144, -940, 808, -21583, 226 } }, + { 576000, { }, { 1107534, 8144, -940, 808, -21583, 226 } }, { 614400, { }, { 1107534, 8144, -940, 808, -21583, 226 } }, + { 652800, { }, { 1149425, 8144, -940, 808, -21583, 226 } }, { 691200, { }, { 1149425, 8144, -940, 808, -21583, 226 } }, + { 729600, { }, { 1191317, 8144, -940, 808, -21583, 226 } }, { 768000, { }, { 1191317, 8144, -940, 808, -21583, 226 } }, + { 806400, { }, { 1233208, 8144, -940, 808, -21583, 226 } }, { 844800, { }, { 1233208, 8144, -940, 808, -21583, 226 } }, + { 883200, { }, { 1275100, 8144, -940, 808, -21583, 226 } }, { 921600, { }, { 1275100, 8144, -940, 808, -21583, 226 } }, - { 998400, { }, { 1316991, 8144, -940, 808, -21583, 226 } }, +// { 998400, { }, { 1316991, 8144, -940, 808, -21583, 226 } }, // { 1075200, { }, { 1358882, 8144, -940, 808, -21583, 226 } }, }, .eristaGpuDvfsTableSLT = { - { 76800, { }, { 730512, 8144, -940, 808, -21583, 226 } }, - { 153600, { }, { 772403, 8144, -940, 808, -21583, 226 } }, - { 230400, { }, { 814294, 8144, -940, 808, -21583, 226 } }, - { 307200, { }, { 856186, 8144, -940, 808, -21583, 226 } }, - { 384000, { }, { 898077, 8144, -940, 808, -21583, 226 } }, - { 460800, { }, { 939969, 8144, -940, 808, -21583, 226 } }, - { 537600, { }, { 981860, 8144, -940, 808, -21583, 226 } }, - { 614400, { }, { 1023751, 8144, -940, 808, -21583, 226 } }, - { 691200, { }, { 1065643, 8144, -940, 808, -21583, 226 } }, - { 768000, { }, { 1107534, 8144, -940, 808, -21583, 226 } }, - { 844800, { }, { 1149426, 8144, -940, 808, -21583, 226 } }, - { 921600, { }, { 1191317, 8144, -940, 808, -21583, 226 } }, + { 76800, { }, { 814294, 8144, -940, 808, -21583, 226 } }, + { 115200, { }, { 814294, 8144, -940, 808, -21583, 226 } }, + { 153600, { }, { 814294, 8144, -940, 808, -21583, 226 } }, + { 192000, { }, { 856185, 8144, -940, 808, -21583, 226 } }, + { 230400, { }, { 856185, 8144, -940, 808, -21583, 226 } }, + { 268800, { }, { 898077, 8144, -940, 808, -21583, 226 } }, + { 307200, { }, { 898077, 8144, -940, 808, -21583, 226 } }, + { 345600, { }, { 939968, 8144, -940, 808, -21583, 226 } }, + { 384000, { }, { 939968, 8144, -940, 808, -21583, 226 } }, + { 422400, { }, { 981860, 8144, -940, 808, -21583, 226 } }, + { 460800, { }, { 981860, 8144, -940, 808, -21583, 226 } }, + { 499200, { }, { 1023751, 8144, -940, 808, -21583, 226 } }, + { 537600, { }, { 1023751, 8144, -940, 808, -21583, 226 } }, + { 576000, { }, { 1065642, 8144, -940, 808, -21583, 226 } }, + { 614400, { }, { 1065642, 8144, -940, 808, -21583, 226 } }, + { 652800, { }, { 1107534, 8144, -940, 808, -21583, 226 } }, + { 691200, { }, { 1107534, 8144, -940, 808, -21583, 226 } }, + { 729600, { }, { 1149425, 8144, -940, 808, -21583, 226 } }, + { 768000, { }, { 1149425, 8144, -940, 808, -21583, 226 } }, + { 806400, { }, { 1191317, 8144, -940, 808, -21583, 226 } }, + { 844800, { }, { 1191317, 8144, -940, 808, -21583, 226 } }, + { 883200, { }, { 1233208, 8144, -940, 808, -21583, 226 } }, + { 921600, { }, { 1233208, 8144, -940, 808, -21583, 226 } }, + { 960000, { }, { 1275100, 8144, -940, 808, -21583, 226 } }, { 998400, { }, { 1275100, 8144, -940, 808, -21583, 226 } }, // { 1075200, { }, { 1316991, 8144, -940, 808, -21583, 226 } }, }, .eristaGpuDvfsTableHigh = { - { 76800, { }, { 646730, 8144, -940, 808, -21583, 226 } }, - { 153600, { }, { 688621, 8144, -940, 808, -21583, 226 } }, - { 230400, { }, { 730512, 8144, -940, 808, -21583, 226 } }, - { 307200, { }, { 772403, 8144, -940, 808, -21583, 226 } }, - { 384000, { }, { 814295, 8144, -940, 808, -21583, 226 } }, - { 460800, { }, { 856186, 8144, -940, 808, -21583, 226 } }, - { 537600, { }, { 898078, 8144, -940, 808, -21583, 226 } }, - { 614400, { }, { 939969, 8144, -940, 808, -21583, 226 } }, - { 691200, { }, { 981860, 8144, -940, 808, -21583, 226 } }, - { 768000, { }, { 1023752, 8144, -940, 808, -21583, 226 } }, - { 844800, { }, { 1065643, 8144, -940, 808, -21583, 226 } }, - { 921600, { }, { 1107535, 8144, -940, 808, -21583, 226 } }, -// { 998400, { }, { 1149426, 8144, -940, 808, -21583, 226 } }, -// { 1075200, { }, { 1275100, 8144, -940, 808, -21583, 226 } }, + { 76800, { }, { 814294, 8144, -940, 808, -21583, 226 } }, + { 115200, { }, { 814294, 8144, -940, 808, -21583, 226 } }, + { 153600, { }, { 814294, 8144, -940, 808, -21583, 226 } }, + { 192000, { }, { 814294, 8144, -940, 808, -21583, 226 } }, + { 230400, { }, { 814294, 8144, -940, 808, -21583, 226 } }, + { 268800, { }, { 856185, 8144, -940, 808, -21583, 226 } }, + { 307200, { }, { 856185, 8144, -940, 808, -21583, 226 } }, + { 345600, { }, { 898077, 8144, -940, 808, -21583, 226 } }, + { 384000, { }, { 898077, 8144, -940, 808, -21583, 226 } }, + { 422400, { }, { 939968, 8144, -940, 808, -21583, 226 } }, + { 460800, { }, { 939968, 8144, -940, 808, -21583, 226 } }, + { 499200, { }, { 981860, 8144, -940, 808, -21583, 226 } }, + { 537600, { }, { 981860, 8144, -940, 808, -21583, 226 } }, + { 576000, { }, { 1023751, 8144, -940, 808, -21583, 226 } }, + { 614400, { }, { 1023751, 8144, -940, 808, -21583, 226 } }, + { 652800, { }, { 1065642, 8144, -940, 808, -21583, 226 } }, + { 691200, { }, { 1065642, 8144, -940, 808, -21583, 226 } }, + { 729600, { }, { 1107534, 8144, -940, 808, -21583, 226 } }, + { 768000, { }, { 1107534, 8144, -940, 808, -21583, 226 } }, + { 806400, { }, { 1149425, 8144, -940, 808, -21583, 226 } }, + { 844800, { }, { 1149425, 8144, -940, 808, -21583, 226 } }, + { 883200, { }, { 1191317, 8144, -940, 808, -21583, 226 } }, + { 921600, { }, { 1191317, 8144, -940, 808, -21583, 226 } }, + { 960000, { }, { 1233208, 8144, -940, 808, -21583, 226 } }, + { 998400, { }, { 1233208, 8144, -940, 808, -21583, 226 } }, + { 1036800, { }, { 1275100, 8144, -940, 808, -21583, 226 } }, + { 1075200, { }, { 1275100, 8144, -940, 808, -21583, 226 } }, }, /* - Mariko GPU DVFS Table: @@ -283,31 +341,32 @@ volatile CustomizeTable C = { { 998400, {}, { 1098475, -13529, -497, -179, 3626, 9 } }, { 1075200, {}, { 1163644, -12688, -648, 0, 1077, 40 } }, { 1152000, {}, { 1204812, -9908, -830, 0, 1469, 110 } }, - // { 1228800, {}, { 1277303, -11675, -859, 0, 3722, 313 } }, + { 1228800, {}, { 1277303, -11675, -859, 0, 3722, 313 } }, // { 1267200, {}, { 1335531, -12567, -867, 0, 3681, 559 } }, // Appending table //{ 1305600, {}, { 1374130, -13725, -859, 0, 4442, 576 } }, }, .marikoGpuDvfsTableSLT = { - { 76800, { }, { 610000, 0, 0, 0, 0, 0 }, }, - { 153600, { }, { 610000, 0, 0, 0, 0, 0 }, }, - { 230400, { }, { 610000, 0, 0, 0, 0, 0 }, }, - { 307200, { }, { 610000, 0, 0, 0, 0, 0 }, }, - { 384000, { }, { 610000, 0, 0, 0, 0, 0 }, }, - { 460800, { }, { 610000, 0, 0, 0, 0, 0 }, }, - { 537600, { }, { 801688, -10900, -163, 298, -10599, 162 }, }, - { 614400, { }, { 824214, -5743, -452, 238, -6325, 81 }, }, - { 691200, { }, { 848830, -3903, -552, 119, -4030, -2 }, }, - { 768000, { }, { 891575, -4409, -584, 0, -2849, 39 }, }, - { 844800, { }, { 940071, -5367, -602, -60, -63, -93 }, }, - { 921600, { }, { 986765, -6637, -614, -179, 1905, -13 }, }, - { 998400, { }, { 1098475, -13529, -497, -179, 3626, 9 }, }, - { 1075200, { }, { 1163644, -12688, -648, 0, 1077, 40 }, }, - { 1152000, { }, { 1204812, -9908, -830, 0, 1469, 110 }, }, - { 1228800, { }, { 1277303, -11675, -859, 0, 3722, 313 }, }, -// { 1267200, { }, { 1335531, -12567, -867, 0, 3681, 559 }, }, + { 76800, {}, { 600000, } }, + { 153600, {}, { 600000, } }, + { 230400, {}, { 600000, } }, + { 307200, {}, { 600000, } }, + { 384000, {}, { 600000, } }, + { 460800, {}, { 795089, -11096, -163, 298, -10421, 162 } }, + { 537600, {}, { 795089, -11096, -163, 298, -10421, 162 } }, + { 614400, {}, { 820606, -6285, -452, 238, -6182, 81 } }, + { 691200, {}, { 846289, -4565, -552, 119, -3958, -2 } }, + { 768000, {}, { 888720, -5110, -584, 0, -2849, 39 } }, + { 844800, {}, { 936634, -6089, -602, -60, -99, -93 } }, + { 921600, {}, { 982562, -7373, -614, -179, 1797, -13 } }, + { 998400, {}, { 1090179, -14125, -497, -179, 3518, 9 } }, + { 1075200, {}, { 1155798, -13465, -648, 0, 1077, 40 } }, + { 1152000, {}, { 1198568, -10904, -830, 0, 1469, 110 } }, + { 1228800, {}, { 1269988, -12707, -859, 0, 3722, 313 } }, + { 1267200, {}, { 1308155, -13694, -867, 0, 3681, 559 } }, }, + .marikoGpuDvfsTableHiOPT = { { 76800, { }, { 590000, 0, 0, 0, 0, 0 }, }, { 153600, { }, { 590000, 0, 0, 0, 0, 0 }, }, @@ -326,112 +385,18 @@ volatile CustomizeTable C = { { 1152000, { }, { 1094475, -12688, -648, 0, 1077, 40 }, }, { 1228800, { }, { 1124475, -12688, -648, 0, 1077, 40 }, }, { 1267200, { }, { 1145060, -12688, -648, 0, 1077, 40 }, }, -// { 1305600, { }, { 1163644, -12688, -648, 0, 1077, 40 }, }, + { 1305600, { }, { 1163644, -12688, -648, 0, 1077, 40 }, }, + { 1344000, { }, { 1182228, -12688, -648, 0, 1077, 40 }, }, + { 1382400, { }, { 1200812, -12688, -648, 0, 1077, 40 }, }, + { 1420800, { }, { 1219396, -12688, -648, 0, 1077, 40 }, }, + { 1459200, { }, { 1237980, -12688, -648, 0, 1077, 40 }, }, + { 1497600, { }, { 1256564, -12688, -648, 0, 1077, 40 }, }, + { 1536000, { }, { 1275148, -12688, -648, 0, 1077, 40 }, }, }, //.eristaMtcTable = const_cast(&EristaMtcTablePlaceholder), //.marikoMtcTable = const_cast(&MarikoMtcTablePlaceholder), -// UV3 tables - -.eristaGpuDvfsTableUv3UnsafeFreqs = { - { 76800, { }, { 814294, 8144, -940, 808, -21583, 226 } }, - { 153600, { }, { 856185, 8144, -940, 808, -21583, 226 } }, - { 230400, { }, { 898077, 8144, -940, 808, -21583, 226 } }, - { 307200, { }, { 939968, 8144, -940, 808, -21583, 226 } }, - { 384000, { }, { 981860, 8144, -940, 808, -21583, 226 } }, - { 460800, { }, { 1023751, 8144, -940, 808, -21583, 226 } }, - { 537600, { }, { 1065642, 8144, -940, 808, -21583, 226 } }, - { 614400, { }, { 1107534, 8144, -940, 808, -21583, 226 } }, - { 691200, { }, { 1149425, 8144, -940, 808, -21583, 226 } }, - { 768000, { }, { 1191317, 8144, -940, 808, -21583, 226 } }, - { 844800, { }, { 1233208, 8144, -940, 808, -21583, 226 } }, - { 921600, { }, { 1275100, 8144, -940, 808, -21583, 226 } }, - { 998400, { }, { 1316991, 8144, -940, 808, -21583, 226 } }, // UNSAFE - { 1075200, { }, { 1358882, 8144, -940, 808, -21583, 226 } }, // UNSAFE -// { 1152000, { }, { 1400773, 8144, -940, 808, -21583, 226 } }, // DANGEROUS -// { 1228800, { }, { 1440773, 8144, -940, 808, -21583, 226 } }, // Cooler -}, - -.marikoGpuDvfsTableUv3UnsafeFreqs = { - { 76800, {}, { 590000, } }, - { 153600, {}, { 590000, } }, - { 230400, {}, { 590000, } }, - { 307200, {}, { 590000, } }, - { 384000, {}, { 590000, } }, - { 460800, {}, { 590000, } }, - { 537600, {}, { 590000, } }, - { 614400, {}, { 590000, } }, - { 691200, {}, { 838712, -7304, -552, 119, -3750, -2 } }, - { 768000, {}, { 880210, -7955, -584, 0, -2849, 39 } }, - { 844800, {}, { 926398, -8892, -602, -60, -384, -93 } }, - { 921600, {}, { 970060, -10108, -614, -179, 1508, -13 } }, - { 998400, {}, { 1065665, -16075, -497, -179, 3213, 9 } }, - { 1075200, {}, { 1132576, -16093, -648, 0, 1077, 40 } }, - { 1152000, {}, { 1180029, -14534, -830, 0, 1469, 110 } }, - { 1228800, {}, { 1248293, -16383, -859, 0, 3722, 313 } }, - { 1267200, {}, { 1286399, -17475, -867, 0, 3681, 559 } }, - { 1305600, {}, { 1286399, -17475, -867, 0, 3681, 559 } }, - { 1305600, {}, { 1324505, -17475, -867, 0, 3681, 559 } }, - { 1344000, {}, { 1362611, -17475, -867, 0, 3681, 559 } }, - { 1382400, {}, { 1400717, -17475, -867, 0, 3681, 559 } }, - { 1420800, {}, { 1438823, -17475, -867, 0, 3681, 559 } }, - { 1459200, {}, { 1476929, -17475, -867, 0, 3681, 559 } }, - { 1497600, {}, { 1515035, -17475, -867, 0, 3681, 559 } }, - { 1536000, {}, { 1553141, -17475, -867, 0, 3681, 559 } }, -}, - -.marikoCpuDvfsTableUnsafeFreqs = { - { 204000, { 732856, -17335, 113 }, {} }, // Unneeded, made to make room for new freqs - { 306000, { 760024, -18195, 113 }, {} }, - { 408000, { 789258, -19055, 113 }, { } }, - { 510000, { 789258, -19915, 113 }, { } }, - { 612000, { 789258, -19055, 113 }, { } }, - { 714000, { 820558, -19915, 113 }, { } }, - { 816000, { 853926, -20775, 113 }, { } }, - { 918000, { 889361, -21625, 113 }, { } }, - { 1020000, { 926862, -22485, 113 }, { } }, - { 1122000, { 926862, -22485, 113 }, { } }, - { 1224000, { 926862, -22485, 113 }, { } }, - { 1326000, { 966431, -23345, 113 }, { } }, - { 1428000, { 1008066, -24205, 113 }, { } }, - { 1581000, { 1051768, -25065, 113 }, { } }, - { 1683000, { 1097537, -25925, 113 }, { } }, - { 1785000, { 1145373, -26785, 113 }, { } }, - { 1887000, { 1195276, -27645, 113 }, { } }, - { 1963500, { 1274006, -29795, 113 }, { } }, - { 2091000, { 1349076, -33235, 113 }, { } }, - { 2193000, { 1386213, -33235, 113 }, { } }, - { 2295000, { 1445416, -34095, 113 }, { } }, - { 2397000, { 1490873, -34955, 113 }, { } }, - { 2499000, { 1580725, -35815, 113 }, { } }, - { 2601000, { 1702903, -36675, 113 }, { } }, - }, -.eristaCpuDvfsTableUnsafeFreqs = { - { 204000, { 721094 }, {} }, - { 306000, { 754040 }, {} }, - { 408000, { 786986 }, {} }, - { 510000, { 819932 }, {} }, - { 612000, { 852878 }, {} }, - { 714000, { 885824 }, {} }, - { 816000, { 918770 }, {} }, - { 918000, { 951716 }, {} }, - { 1020000, { 984662 }, { -2875621, 358099, -8585 } }, - { 1122000, { 1017608 }, { -52225, 104159, -2816 } }, - { 1224000, { 1050554 }, { 1076868, 8356, -727 } }, - { 1326000, { 1083500 }, { 2208191, -84659, 1240 } }, - { 1428000, { 1116446 }, { 2519460, -105063, 1611 } }, - { 1581000, { 1130000 }, { 2889664, -122173, 1834 } }, - { 1683000, { 1168000 }, { 5100873, -279186, 4747 } }, - { 1785000, { 1227500 }, { 5100873, -279186, 4747 } }, - // Appending table - { 1887000, { 1235000 }, { 5200873, -279186, 4747 } }, - { 1963500, { 1235000 }, { 5300873, -279186, 4747 } }, - { 2091000, { 1235000 }, { 5400873, -289186, 4847 } }, - { 2193000, { 1235000 }, { 5500873, -299186, 4947 } }, - { 2295000, { 1235000 }, { 5600873, -239186, 5047 } }, - // { 2397000, { 1235000 }, { 5700873, -249186, 5047 } }, - }, }; } diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/customize.hpp b/Source/Atmosphere/stratosphere/loader/source/oc/customize.hpp index 690fab87..2dcdaff4 100644 --- a/Source/Atmosphere/stratosphere/loader/source/oc/customize.hpp +++ b/Source/Atmosphere/stratosphere/loader/source/oc/customize.hpp @@ -60,11 +60,6 @@ u32 eristaCpuUV; u32 eristaGpuUV; - u32 enableMarikoGpuUnsafeFreqs; - u32 enableEristaGpuUnsafeFreqs; - - u32 enableMarikoCpuUnsafeFreqs; - u32 enableEristaCpuUnsafeFreqs; u32 commonGpuVoltOffset; @@ -88,7 +83,7 @@ u32 marikoGpuVmax; u32 marikoGpuVoltArray[24]; - u32 eristaGpuVoltArray[14]; + u32 eristaGpuVoltArray[27]; CustomizeCpuDvfsTable eristaCpuDvfsTable; CustomizeCpuDvfsTable marikoCpuDvfsTable; @@ -104,11 +99,6 @@ CustomizeGpuDvfsTable marikoGpuDvfsTableHiOPT; //EristaMtcTable* eristaMtcTable; //MarikoMtcTable* marikoMtcTable; - CustomizeGpuDvfsTable eristaGpuDvfsTableUv3UnsafeFreqs; - CustomizeGpuDvfsTable marikoGpuDvfsTableUv3UnsafeFreqs; - CustomizeCpuDvfsTable marikoCpuDvfsTableUnsafeFreqs; - CustomizeCpuDvfsTable eristaCpuDvfsTableUnsafeFreqs; - } CustomizeTable; //static_assert(sizeof(CustomizeTable) == sizeof(u8) * 4 + sizeof(u32) * 10 + sizeof(CustomizeCpuDvfsTable) * 5 + sizeof(void*) * 2); //static_assert(sizeof(CustomizeTable) == 7000); diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.cpp b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.cpp index 0512f442..6ca4f8c6 100644 --- a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.cpp +++ b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.cpp @@ -94,14 +94,8 @@ void SafetyCheck() { R_SUCCEED(); } }; - u32 eristaCpuDvfsMaxFreq; - if (C.enableEristaCpuUnsafeFreqs) { - eristaCpuDvfsMaxFreq = static_cast(GetDvfsTableLastEntry(C.eristaCpuDvfsTableUnsafeFreqs)->freq); - } else { - eristaCpuDvfsMaxFreq = static_cast(GetDvfsTableLastEntry(C.eristaCpuDvfsTable)->freq); - } + u32 eristaCpuDvfsMaxFreq = static_cast(GetDvfsTableLastEntry(C.eristaCpuDvfsTable)->freq); u32 marikoCpuDvfsMaxFreq; - if(!C.enableMarikoCpuUnsafeFreqs) { if (C.marikoCpuUV) { marikoCpuDvfsMaxFreq = static_cast( GetDvfsTableLastEntry(C.marikoCpuDvfsTableSLT)->freq @@ -111,9 +105,6 @@ void SafetyCheck() { GetDvfsTableLastEntry(C.marikoCpuDvfsTable)->freq ); } - } else { - marikoCpuDvfsMaxFreq = static_cast(GetDvfsTableLastEntry(C.marikoCpuDvfsTableUnsafeFreqs)->freq); - } u32 eristaGpuDvfsMaxFreq; switch (C.eristaGpuUV) { @@ -124,17 +115,8 @@ void SafetyCheck() { eristaGpuDvfsMaxFreq = static_cast(GetDvfsTableLastEntry(C.eristaGpuDvfsTableSLT)->freq); break; case 2: - eristaGpuDvfsMaxFreq = static_cast(GetDvfsTableLastEntry(C.eristaGpuDvfsTableHigh)->freq); - break; case 3: - if(C.enableEristaGpuUnsafeFreqs) - { - eristaGpuDvfsMaxFreq = static_cast(GetDvfsTableLastEntry(C.eristaGpuDvfsTableUv3UnsafeFreqs)->freq); - } - else - { - eristaGpuDvfsMaxFreq = static_cast(GetDvfsTableLastEntry(C.eristaGpuDvfsTable)->freq); - } + eristaGpuDvfsMaxFreq = static_cast(GetDvfsTableLastEntry(C.eristaGpuDvfsTableHigh)->freq); break; default: eristaGpuDvfsMaxFreq = static_cast(GetDvfsTableLastEntry(C.eristaGpuDvfsTable)->freq); @@ -150,17 +132,8 @@ void SafetyCheck() { marikoGpuDvfsMaxFreq = static_cast(GetDvfsTableLastEntry(C.marikoGpuDvfsTableSLT)->freq); break; case 2: - marikoGpuDvfsMaxFreq = static_cast(GetDvfsTableLastEntry(C.marikoGpuDvfsTableHiOPT)->freq); - break; case 3: - if(C.enableMarikoGpuUnsafeFreqs) - { - marikoGpuDvfsMaxFreq = static_cast(GetDvfsTableLastEntry(C.marikoGpuDvfsTableUv3UnsafeFreqs)->freq); - } - else - { - marikoGpuDvfsMaxFreq = static_cast(GetDvfsTableLastEntry(C.marikoGpuDvfsTable)->freq); - } + marikoGpuDvfsMaxFreq = static_cast(GetDvfsTableLastEntry(C.marikoGpuDvfsTableHiOPT)->freq); break; default: marikoGpuDvfsMaxFreq = static_cast(GetDvfsTableLastEntry(C.marikoGpuDvfsTable)->freq); diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.hpp b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.hpp index 511d8b58..525dcbe7 100644 --- a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.hpp +++ b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv.hpp @@ -94,7 +94,9 @@ namespace ams::ldr::oc::pcv {}, }; - constexpr u32 GpuClkPllLimit = 1300'000'000; + constexpr u32 GpuClkPllLimit = 2600'000; + + constexpr u32 GpuClkMax = 1300'000'000; /* GPU Max Clock asm Pattern: * @@ -260,21 +262,13 @@ namespace ams::ldr::oc::pcv cvb_entry_t *customize_table = nullptr; // impossible to reach, there will always be a way to set a pointer if (isMariko) { - if (C.enableMarikoCpuUnsafeFreqs) { - customize_table = const_cast(C.marikoCpuDvfsTableUnsafeFreqs); + if (C.marikoCpuUV) { + customize_table = const_cast(C.marikoCpuDvfsTableSLT); } else { - if (C.marikoCpuUV) { - customize_table = const_cast(C.marikoCpuDvfsTableSLT); - } else { - customize_table = const_cast(C.marikoCpuDvfsTable); - } + customize_table = const_cast(C.marikoCpuDvfsTable); } } else { - if (C.enableEristaCpuUnsafeFreqs) { - customize_table = const_cast(C.eristaCpuDvfsTableUnsafeFreqs); - } else { customize_table = const_cast(C.eristaCpuDvfsTable); - } } u32 cpu_max_volt = isMariko ? C.marikoCpuMaxVolt : C.eristaCpuMaxVolt; u32 cpu_freq_threshold = 1020'000; @@ -328,14 +322,8 @@ namespace ams::ldr::oc::pcv customize_table = const_cast(C.marikoGpuDvfsTableSLT); break; case 2: - customize_table = const_cast(C.marikoGpuDvfsTableHiOPT); - break; case 3: - if(C.enableMarikoGpuUnsafeFreqs) { - customize_table = const_cast(C.marikoGpuDvfsTableUv3UnsafeFreqs); - } else { - customize_table = const_cast(C.marikoGpuDvfsTable); - } + customize_table = const_cast(C.marikoGpuDvfsTableHiOPT); break; default: customize_table = const_cast(C.marikoGpuDvfsTable); @@ -350,14 +338,8 @@ namespace ams::ldr::oc::pcv customize_table = const_cast(C.eristaGpuDvfsTableSLT); break; case 2: - customize_table = const_cast(C.eristaGpuDvfsTableHigh); - break; case 3: - if(C.enableEristaGpuUnsafeFreqs) { - customize_table = const_cast(C.eristaGpuDvfsTableUv3UnsafeFreqs); - } else { - customize_table = const_cast(C.eristaGpuDvfsTable); - } + customize_table = const_cast(C.eristaGpuDvfsTableHigh); break; default: customize_table = const_cast(C.eristaGpuDvfsTable); diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_erista.cpp b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_erista.cpp index 40cf502f..15f3db19 100644 --- a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_erista.cpp +++ b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_erista.cpp @@ -26,21 +26,13 @@ namespace ams::ldr::oc::pcv::erista { Result CpuFreqVdd(u32* ptr) { dvfs_rail* entry = reinterpret_cast(reinterpret_cast(ptr) - offsetof(dvfs_rail, freq)); - R_UNLESS(entry->id == 1, ldr::ResultInvalidCpuFreqVddEntry()); - R_UNLESS(entry->min_mv == 250'000, ldr::ResultInvalidCpuFreqVddEntry()); - R_UNLESS(entry->step_mv == 5000, ldr::ResultInvalidCpuFreqVddEntry()); - R_UNLESS(entry->max_mv == 1525'000, ldr::ResultInvalidCpuFreqVddEntry()); - - if (C.eristaCpuUV) { - if(!C.enableEristaCpuUnsafeFreqs) { - PATCH_OFFSET(ptr, GetDvfsTableLastEntry(C.eristaCpuDvfsTable)->freq); - } else { - PATCH_OFFSET(ptr, GetDvfsTableLastEntry(C.eristaCpuDvfsTableUnsafeFreqs)->freq); - } - } else { - PATCH_OFFSET(ptr, GetDvfsTableLastEntry(C.eristaCpuDvfsTable)->freq); - } - + PATCH_OFFSET(ptr, GetDvfsTableLastEntry(C.eristaCpuDvfsTable)->freq); + R_SUCCEED(); +} +Result GpuVmin(u32 *ptr) { + if (!C.eristaGpuVmin) + R_SKIP(); + PATCH_OFFSET(ptr, (int)C.eristaGpuVmin); R_SUCCEED(); } @@ -127,14 +119,8 @@ namespace ams::ldr::oc::pcv::erista { max_clock = GetDvfsTableLastEntry(C.eristaGpuDvfsTableSLT)->freq; break; case 2: - max_clock = GetDvfsTableLastEntry(C.eristaGpuDvfsTableHigh)->freq; - break; case 3: - if(C.enableEristaGpuUnsafeFreqs) { - max_clock = GetDvfsTableLastEntry(C.eristaGpuDvfsTableUv3UnsafeFreqs)->freq; - } else { - max_clock = GetDvfsTableLastEntry(C.eristaGpuDvfsTable)->freq; - } + max_clock = GetDvfsTableLastEntry(C.eristaGpuDvfsTableHigh)->freq; break; default: max_clock = GetDvfsTableLastEntry(C.eristaGpuDvfsTable)->freq; @@ -732,6 +718,7 @@ namespace ams::ldr::oc::pcv::erista { {"CPU Volt Dfll", &CpuVoltDfll, 1, nullptr, 0xFFEAD0FF }, {"GPU Freq Table", GpuFreqCvbTable, 1, nullptr, GpuCvbDefaultMaxFreq}, {"GPU Freq Asm", &GpuFreqMaxAsm, 2, &GpuMaxClockPatternFn}, + {"GPU Volt Thermal", &GpuFreqMaxAsm, 1, &GpuMaxClockPatternFn}, {"GPU Freq PLL", &GpuFreqPllLimit, 1, nullptr, GpuClkPllLimit}, {"MEM Freq Mtc", &MemFreqMtcTable, 0, nullptr, EmcClkOSLimit}, {"MEM Freq Max", &MemFreqMax, 0, nullptr, EmcClkOSLimit}, diff --git a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_mariko.cpp b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_mariko.cpp index 500dad41..beec6db3 100644 --- a/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_mariko.cpp +++ b/Source/Atmosphere/stratosphere/loader/source/oc/pcv/pcv_mariko.cpp @@ -44,19 +44,12 @@ namespace ams::ldr::oc::pcv::mariko { R_UNLESS(entry->min_mv == 250'000, ldr::ResultInvalidCpuFreqVddEntry()); R_UNLESS(entry->step_mv == 5000, ldr::ResultInvalidCpuFreqVddEntry()); R_UNLESS(entry->max_mv == 1525'000, ldr::ResultInvalidCpuFreqVddEntry()); - if (C.enableMarikoCpuUnsafeFreqs) { + if (C.marikoCpuUV) + { + PATCH_OFFSET(ptr, GetDvfsTableLastEntry(C.marikoCpuDvfsTableSLT)->freq); + } else { PATCH_OFFSET(ptr, GetDvfsTableLastEntry(C.marikoCpuDvfsTable)->freq); } - else { - if (C.marikoCpuUV) { - if (!C.enableMarikoCpuUnsafeFreqs) { - PATCH_OFFSET(ptr, GetDvfsTableLastEntry(C.marikoCpuDvfsTableSLT)->freq); - } - else { - PATCH_OFFSET(ptr, GetDvfsTableLastEntry(C.marikoCpuDvfsTableUnsafeFreqs)->freq); - } - } - } R_SUCCEED(); } @@ -136,12 +129,12 @@ namespace ams::ldr::oc::pcv::mariko { PATCH_OFFSET(&(entry->tune1_low), 0x021107FF); PATCH_OFFSET(&(entry->tune1_high), 0x026617FF); break; - case 8: - PATCH_OFFSET(&(entry->tune0_low), 0x0000FFFF); // EOS UV6 - PATCH_OFFSET(&(entry->tune0_high), 0x0000FFFF); - PATCH_OFFSET(&(entry->tune1_low), 0x021107FF); - PATCH_OFFSET(&(entry->tune1_high), 0x028817FF); - break; + // case 8: + // PATCH_OFFSET(&(entry->tune0_low), 0x0000FFFF); // EOS UV6 + // PATCH_OFFSET(&(entry->tune0_high), 0x0000FFFF); + // PATCH_OFFSET(&(entry->tune1_low), 0x021107FF); + // PATCH_OFFSET(&(entry->tune1_high), 0x028817FF); + // break; default: break; } @@ -168,15 +161,8 @@ namespace ams::ldr::oc::pcv::mariko { max_clock = GetDvfsTableLastEntry(C.marikoGpuDvfsTableSLT)->freq; break; case 2: - max_clock = GetDvfsTableLastEntry(C.marikoGpuDvfsTableHiOPT)->freq; - break; case 3: - if (C.enableMarikoGpuUnsafeFreqs) { - max_clock = GetDvfsTableLastEntry(C.marikoGpuDvfsTableUv3UnsafeFreqs)->freq; - } - else { - max_clock = GetDvfsTableLastEntry(C.marikoGpuDvfsTable)->freq; - } + max_clock = GetDvfsTableLastEntry(C.marikoGpuDvfsTableHiOPT)->freq; break; default: max_clock = GetDvfsTableLastEntry(C.marikoGpuDvfsTable)->freq; @@ -194,16 +180,13 @@ namespace ams::ldr::oc::pcv::mariko { } Result GpuFreqPllLimit(u32 *ptr) { - clk_pll_param *entry = reinterpret_cast(ptr); + int UPPER_GPU_FREQ = -1; // uncap the gpu frequency + PATCH_OFFSET(ptr, UPPER_GPU_FREQ); + R_SUCCEED(); + } - // All zero except for freq - for (size_t i = 1; i < sizeof(clk_pll_param) / sizeof(u32); i++) { - R_UNLESS(*(ptr + i) == 0, ldr::ResultInvalidGpuPllEntry()); - } - - // Double the max clk simply - u32 max_clk = entry->freq * 2; - entry->freq = max_clk; + Result GpuFreqMax(u32 *ptr) { + PATCH_OFFSET(ptr, 3600000); R_SUCCEED(); } @@ -657,7 +640,8 @@ namespace ams::ldr::oc::pcv::mariko { {"CPU Volt Dfll", &CpuVoltDfll, 1, nullptr, 0x0000FFCF}, {"GPU Freq Table", GpuFreqCvbTable, 1, nullptr, GpuCvbDefaultMaxFreq}, {"GPU Freq Asm", &GpuFreqMaxAsm, 2, &GpuMaxClockPatternFn}, - {"GPU Freq PLL", &GpuFreqPllLimit, 1, nullptr, GpuClkPllLimit}, + {"GPU Freq Max (Patch 1)", &GpuFreqMax, 1, nullptr, GpuClkMax}, + {"GPU Freq PLL (Patch 2)", &GpuFreqPllLimit, 0, nullptr, GpuClkPllLimit}, {"MEM Freq Mtc", &MemFreqMtcTable, 0, nullptr, EmcClkOSLimit}, {"MEM Freq Dvb", &MemFreqDvbTable, 1, nullptr, EmcClkOSLimit}, {"MEM Freq Max", &MemFreqMax, 0, nullptr, EmcClkOSLimit}, diff --git a/Source/Configurator/dist/hocconfig.exe b/Source/Configurator/dist/hocconfig.exe index 262289a4..64bf345f 100644 Binary files a/Source/Configurator/dist/hocconfig.exe and b/Source/Configurator/dist/hocconfig.exe differ diff --git a/Source/Configurator/loader_edit.kip b/Source/Configurator/loader_edit.kip new file mode 100644 index 00000000..d2022b50 Binary files /dev/null and b/Source/Configurator/loader_edit.kip differ diff --git a/Source/Configurator/run.bat b/Source/Configurator/run.bat index 4c4e7796..b3642477 100644 --- a/Source/Configurator/run.bat +++ b/Source/Configurator/run.bat @@ -1 +1 @@ -python3 src/main.py \ No newline at end of file +python src/main.py \ No newline at end of file diff --git a/Source/Configurator/src/cpu.py b/Source/Configurator/src/cpu.py index 30376603..94263fb0 100644 --- a/Source/Configurator/src/cpu.py +++ b/Source/Configurator/src/cpu.py @@ -51,20 +51,6 @@ def populate(): small=True, tag="c_freqs_info" ) - dpg.add_combo( - items=["Disabled (0)", "Enabled (1)"], - default_value="Disabled (0)", - label="Enable CPU Unsafe Frequencies (Mariko)", - callback=k.grab_kip_storage_values_no_mult, - tag="enableMarikoCpuUnsafeFreqs" - ) - dpg.add_combo( - items=["Disabled (0)", "Enabled (1)"], - default_value="Disabled (0)", - label="Enable CPU Unsafe Frequencies (Erista)", - callback=k.grab_kip_storage_values_no_mult, - tag="enableEristaCpuUnsafeFreqs" - ) dpg.add_combo( items=freqs_mhz_cpu_label, diff --git a/Source/Configurator/src/defaults.py b/Source/Configurator/src/defaults.py index 33d683b3..0841e684 100644 --- a/Source/Configurator/src/defaults.py +++ b/Source/Configurator/src/defaults.py @@ -36,10 +36,6 @@ class Defaults: # This almost always never needs to be updated as pulling from t self.marikoGpuUV = 0 self.eristaCpuUV = 0 self.eristaGpuUV = 0 - self.enableMarikoGpuUnsafeFreqs = 0 - self.enableEristaGpuUnsafeFreqs = 0 - self.enableMarikoCpuUnsafeFreqs = 0 - self.enableEristaCpuUnsafeFreqs = 0 self.commonGpuVoltOffset = 0 self.marikoEmcDvbShift = 0 self.t1_tRCD = 0 diff --git a/Source/Configurator/src/gpu.py b/Source/Configurator/src/gpu.py index 43ce1d16..517efd88 100644 --- a/Source/Configurator/src/gpu.py +++ b/Source/Configurator/src/gpu.py @@ -85,20 +85,6 @@ def populate(): tag="freqs_info" ) dpg.add_checkbox(label="GPU Scheduling", default_value=True, tag="gpu_sched", callback=toggle_gpu_sched) - dpg.add_combo( - items=["Disabled (0)", "Enabled (1)"], - default_value="Disabled (0)", - label="Enable GPU Unsafe Frequencies (Mariko)", - callback=k.grab_kip_storage_values_no_mult, - tag="enableMarikoGpuUnsafeFreqs" - ) - dpg.add_combo( - items=["Disabled (0)", "Enabled (1)"], - default_value="Disabled (0)", - label="Enable GPU Unsafe Frequencies (Erista)", - callback=k.grab_kip_storage_values_no_mult, - tag="enableEristaGpuUnsafeFreqs" - ) dpg.add_separator(label="Voltages") diff --git a/Source/Configurator/src/main.py b/Source/Configurator/src/main.py index 63479a54..a05c3d70 100644 --- a/Source/Configurator/src/main.py +++ b/Source/Configurator/src/main.py @@ -44,10 +44,10 @@ import misc true = True false = False -# if getattr(sys, 'frozen', False): -assets_path = os.path.join(sys._MEIPASS, 'assets/') -# else: - # assets_path = os.path.join(os.path.dirname(__file__), '../assets/') +if getattr(sys, 'frozen', False): + assets_path = os.path.join(sys._MEIPASS, 'assets/') +else: + assets_path = os.path.join(os.path.dirname(__file__), '../assets/') cooler_image_path = assets_path + "coolerhd.png" # coolerHD Emoji from OC server cooler_image = Image.open(cooler_image_path).convert("RGBA") diff --git a/Source/Configurator/src/settings.py b/Source/Configurator/src/settings.py index 531e732b..3f48b8b9 100644 --- a/Source/Configurator/src/settings.py +++ b/Source/Configurator/src/settings.py @@ -60,6 +60,7 @@ freqs_mhz_cpu = [ variables = [ ("custRev", "u32"), ("mtcConf", "u32"), + ("hpMode", "u32"), ("commonCpuBoostClock", "u32"), ("commonEmcMemVolt", "u32"), ("eristaCpuMaxVolt", "u32"), @@ -71,10 +72,6 @@ variables = [ ("marikoGpuUV", "u32"), ("eristaCpuUV", "u32"), ("eristaGpuUV", "u32"), - ("enableMarikoGpuUnsafeFreqs", "u32"), - ("enableEristaGpuUnsafeFreqs", "u32"), - ("enableMarikoCpuUnsafeFreqs", "u32"), - ("enableEristaCpuUnsafeFreqs", "u32"), ("commonGpuVoltOffset", "u32"), ("marikoEmcDvbShift", "u32"), # advanced config @@ -156,10 +153,6 @@ def load_all_vars(): c.load_entry_object("marikoGpuUV", 4) c.load_entry_object("eristaCpuUV", 5) c.load_entry_object("eristaGpuUV", 4) - c.load_entry_object("enableMarikoGpuUnsafeFreqs", 0) - c.load_entry_object("enableEristaGpuUnsafeFreqs", 0) - c.load_entry_object("enableMarikoCpuUnsafeFreqs", 0) - c.load_entry_object("enableEristaCpuUnsafeFreqs", 0) c.load_entry_object("commonGpuVoltOffset", 3) c.load_entry_object("marikoEmcDvbShift", 0) diff --git a/Source/MemTesterNX/source/main.c b/Source/MemTesterNX/source/main.c index 0f8ef610..12dc8ae7 100644 --- a/Source/MemTesterNX/source/main.c +++ b/Source/MemTesterNX/source/main.c @@ -13,478 +13,484 @@ * */ -#define __version__ "4.5.1-multithread" + #define __version__ "4.5.1-multithread" -// Include the most common headers from the C standard library -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "types.h" -#include "sizes.h" -#include "tests.h" -#include - -PadState pad; -unsigned short dividend = 1; - -void waitForAnyKey() { - while (appletMainLoop()) - { - padUpdate(&pad); - - u64 kDown = padGetButtonsDown(&pad); - - if (kDown) - break; - - consoleUpdate(NULL); - } -} - -void ShowErr(const char* err, const char* details, Result rc) { - AppletStorage errStor; - LibAppletArgs args; - AppletHolder currentApplet; - - appletCreateLibraryApplet(¤tApplet, AppletId_LibraryAppletError, LibAppletMode_AllForeground); - libappletArgsCreate(&args, 1); - libappletArgsPush(&args, ¤tApplet); - appletCreateStorage(&errStor, 0x1018); - u8 argBuf[0x1018] = {0}; - argBuf[0] = 1; - - *(u64*)&argBuf[8] = (((rc & 0x1ffu) + 2000) | (((rc >> 9) & 0x1fff & 0x1fffll) << 32)); - strcpy((char*) &argBuf[24], err); - strcpy((char*) &argBuf[0x818], details); - appletStorageWrite(&errStor, 0, argBuf, 0x1018); - appletHolderPushInData(¤tApplet, &errStor); - - appletHolderStart(¤tApplet); - appletHolderJoin(¤tApplet); - appletHolderClose(¤tApplet); - appletHolderRequestExit(¤tApplet); -} - -double gettime(void) -{ - struct timeval tv; - gettimeofday(&tv, NULL); - return (double)((int64_t)tv.tv_sec * 1000000 + tv.tv_usec) / 1000000.; -} - -struct test tests[] = { - { "Random Value", test_random_value }, - { "Compare XOR", test_xor_comparison }, - { "Compare SUB", test_sub_comparison }, - { "Compare MUL", test_mul_comparison }, - { "Compare DIV",test_div_comparison }, - { "Compare OR", test_or_comparison }, - { "Compare AND", test_and_comparison }, - { "Sequential Increment", test_seqinc_comparison }, - { "Solid Bits", test_solidbits_comparison }, - { "Block Sequential", test_blockseq_comparison }, - { "Checkerboard", test_checkerboard_comparison }, - { "Bit Spread", test_bitspread_comparison }, - { "Bit Flip (Slow)", test_bitflip_comparison }, - { "Walking Ones", test_walkbits1_comparison }, - { "Walking Zeroes", test_walkbits0_comparison }, -#ifdef TEST_NARROW_WRITES - { "8-bit Writes", test_8bit_wide_random }, - { "16-bit Writes", test_16bit_wide_random }, -#endif - { NULL, NULL } -}; - -struct test stress_tests[] = { - { "Stress memcpy x128", test_stress_memcpy }, - { "Stress memset x128", test_stress_memset }, - { "Stress memcmp x 32", test_stress_memcmp }, - { NULL, NULL } -}; - -int memtester_pagesize(void) { - printf("using pagesize of 4096\n"); - return 4096; -} - -/* Global vars - so tests have access to this information */ -int use_phys = 0; -off_t physaddrbase = 0; -int testJobId[4] = {0}; -int testWorkerReport[4] = {0}; -size_t bufsize[4], wantbytes[4]; -void volatile *aligned[4]; -Thread threads[5]; -struct test* test_select = tests; - -void testWorker(int div) -{ - // Get ready - while (testJobId[div] != -2) - svcSleepThread(10000000ULL); - - while (true) - { - int currentJobId = -1; - - // Stuck address - while (testJobId[div] != currentJobId) - svcSleepThread(10000000ULL); - - if (!test_stuck_address(aligned[div], bufsize[div]/sizeof(ul))) - { - testWorkerReport[div] = 1; - currentJobId++; - } - else - { - testWorkerReport[div] = -1; - return; - } - - // tests[], currentJobId = 0 here - while (test_select[currentJobId].name) - { - while (testJobId[div] != currentJobId) - svcSleepThread(10000000ULL); - - int test_rc = test_select[currentJobId].fp(aligned[div], ((size_t)aligned[div] + bufsize[div]/2), bufsize[div]/sizeof(ul)/2); - if (!test_rc) - { - testWorkerReport[div] = 1; - currentJobId++; - } - else - { - testWorkerReport[div] = -1; - return; - } - } - } -} - -void testWorker0(void*) { testWorker(0); } -void testWorker1(void*) { testWorker(1); } -void testWorker2(void*) { testWorker(2); } -void testWorker3(void*) { testWorker(3); } - -void* workers[] = { - testWorker0, - testWorker1, - testWorker2, - testWorker3, -}; - -void LblUpdate() -{ - smInitialize(); - lblInitialize(); - LblBacklightSwitchStatus lblstatus = LblBacklightSwitchStatus_Disabled; - lblGetBacklightSwitchStatus(&lblstatus); - if (lblstatus) { - lblSwitchBacklightOff(0); - } else { - lblSwitchBacklightOn(0); - } - lblExit(); - smExit(); -} - -void keyListener() -{ - while (true) - { - padUpdate(&pad); - u64 kDown = padGetButtonsDown(&pad); - if (kDown & HidNpadButton_Minus) - { - LblUpdate(); - } - svcSleepThread(10000000ULL); - } -} - -// Main program entrypoint -int main(int argc, char* argv[]) -{ - if(appletGetAppletType() != AppletType_Application) { - ShowErr("Running in applet mode\nMemTesterNX requires full memory mode.\nPlease launch hbmenu by holding R on an APP (e.g. a game) NOT an applet (e.g. Gallery)", "", 0); - return 0; - } - - appletReportUserIsActive(); - - consoleInit(NULL); - - padConfigureInput(1, HidNpadStyleSet_NpadStandard); - - padInitializeDefault(&pad); - - ull loop, i; - unsigned short div, testThreads = 3; - size_t pagesize, wantraw, wantbytes_orig; - ptrdiff_t pagesizemask; - void volatile *buf[4]; - int memshift; - ull totalmem = 0; - int numOfMallocs = 0; - bool isDevKit8GB = false; - - printf("MemTesterNX version " __version__ " (%d-bit)\n"\ - "Based on memtester. Copyright (C) 2001-2020 Charles Cazabon, 2021 KazushiMe.\n"\ - "Licensed under the GNU General Public License version 2 (only).\n\n"\ - "Support full RAM test (up to 8GB) with 3-4 threads.\n"\ - "It will be looping forever until error occurs or user exits to HOME screen.\n\n"\ - "Press A: long test\n"\ - "Press X: fast test\n"\ - "Press Y: stress DRAM (memcpy, memset and memcmp)\n"\ - "Press any other key: exit\n\n", - UL_LEN); - - while (appletMainLoop()) - { - padUpdate(&pad); - - u64 kDown = padGetButtonsDown(&pad); - - if (kDown & HidNpadButton_A) - { - break; - } - else if (kDown & HidNpadButton_X) - { - dividend = 4; - break; - } - else if (kDown & HidNpadButton_Y) - { - dividend = 16; - test_select = stress_tests; - break; - } - else if (kDown) - { - consoleExit(NULL); - exit(0); - } - - consoleUpdate(NULL); - } - - // Disable auto sleep and request CPU Boost mode - appletSetAutoSleepDisabled(true); - appletSetCpuBoostMode(ApmCpuBoostMode_FastLoad); - - pagesize = memtester_pagesize(); - pagesizemask = (ptrdiff_t) ~(pagesize - 1); - printf("pagesizemask is 0x%tx\n", pagesizemask); - consoleUpdate(NULL); - - memshift = 20; /* megabytes */ - wantraw = 2048; // HOS limit - - wantbytes_orig = ((size_t) wantraw << memshift); - - // Allocate as much RAM as possible. - for (div = 0; div <= 3; div++) - { - buf[div] = NULL; - wantbytes[div] = wantbytes_orig; - - while (!buf[div] && wantbytes[div]) { - buf[div] = (void volatile *) malloc(wantbytes[div]); - if (!buf[div]) - wantbytes[div] -= pagesize; - } - - totalmem += wantbytes[div]; - - if ((wantbytes[div] >> memshift) < 2047) - { - numOfMallocs = div + 1; - break; - } - } - - for (div = 0; div < numOfMallocs; div++) - { - free((void *)buf[div]); - } - - // Unknown: Not sure if devkit could use full 8GB in application space - if ((totalmem >> memshift) > 3 * 2047) - { - isDevKit8GB = true; - testThreads = 4; - } - - // Create workers - for (div = 0; div < testThreads; div++) - { - Result rc; - rc = threadCreate(&threads[div], workers[div], NULL, NULL, 0x1000, 0x2C, div == 3 ? -2 : div); - if (R_FAILED(rc)) - { - printf("Fatal: threadCreate[%d] failed: 0x%X\n", div, rc); - consoleUpdate(NULL); - } - else - { - totalmem -= 0x1000; - } - } - - // keyListener - { - const int kl = testThreads; - Result rc = threadCreate(&threads[kl], keyListener, NULL, NULL, 0x1000, 0x20, -2); - if (R_FAILED(rc)) - { - printf("Fatal: threadCreate[%d] failed: 0x%X\n", div, rc); - consoleUpdate(NULL); - } - threadStart(&threads[kl]); - } - - printf("\nTotal RAM available: %lldMB\n\n", totalmem >> memshift); - consoleUpdate(NULL); - - // Redistribute RAM allocation equally to testThreads workers - for (div = 0; div < testThreads; div++) - { - buf[div] = NULL; - if (isDevKit8GB) - { - if (div != 3) - wantbytes[div] = totalmem / 3; - else - wantbytes[div] = 2047; - } - else - { - wantbytes[div] = totalmem / testThreads; - } - - while (!buf[div] && wantbytes[div]) { - buf[div] = (void volatile *) malloc(wantbytes[div]); - if (!buf[div]) - wantbytes[div] -= pagesize; - } - - bufsize[div] = wantbytes[div]; - - /* Do alighnment here as well, as some cases won't trigger above if you - define out the use of mlock() (cough HP/UX 10 cough). */ - if ((size_t) buf[div] % pagesize) { - /* printf("aligning to page -- was 0x%tx\n", buf); */ - aligned[div] = (void volatile *) ((size_t) buf[div] & pagesizemask) + pagesize; - /* printf(" now 0x%tx -- lost %d bytes\n", aligned, - * (size_t) aligned - (size_t) buf); - */ - bufsize[div] -= ((size_t) aligned[div] - (size_t) buf[div]); - } else { - aligned[div] = buf[div]; - } - - printf("Alloc %d: got %lluMB (%llu bytes)\n", div+1, (ull) wantbytes[div] >> memshift, (ull) wantbytes[div]); - consoleUpdate(NULL); - } - - // Start workers - for (div = 0; div < testThreads; div++) - { - Result rc; - rc = threadStart(&threads[div]); - if (R_FAILED(rc)) - { - printf("Fatal: threadStart[%d] failed: 0x%X\n", div, rc); - consoleUpdate(NULL); - } - } - - for(loop=1;;loop++) - { - // Set testJobId to -2(Ready) - for (int j = 0; j < testThreads; j++) - testJobId[j] = -2; - - printf("Loop %llu:\n", loop); - - // Stuck address (-1) - printf(" %-20s: ", "Stuck Address"); - consoleUpdate(NULL); - for (int j = 0; j < testThreads; j++) - testJobId[j] = -1; - - for (int j = 0; j < testThreads; ) - { - switch (testWorkerReport[j]) - { - case 0: - svcSleepThread(10000000ULL); - break; - case -1: - printf("Alloc %d/%d: Error detected!\nPress any key to exit.\n", j+1, testThreads+1); - consoleUpdate(NULL); - waitForAnyKey(); - consoleExit(NULL); - return 0; - case 1: - testWorkerReport[j] = 0; - j++; - continue; - } - } - printf("ok\n"); - consoleUpdate(NULL); - - // tests[] - for (i = 0 ;; i++) { - if (!test_select[i].name) - break; - - printf(" %-20s: ...", test_select[i].name); - consoleUpdate(NULL); - for (int j = 0; j < testThreads; j++) - testJobId[j] = i; - - double start_sec = gettime(); - for (int j = 0; j < testThreads; ) - { - switch (testWorkerReport[j]) - { - case 0: - svcSleepThread(10000000ULL); - continue; - case -1: - printf("Alloc %d/%d: Error detected!\nPress any key to exit.\n", j+1, testThreads+1); - consoleUpdate(NULL); - waitForAnyKey(); - consoleExit(NULL); - return 0; - case 1: - testWorkerReport[j] = 0; - j++; - continue; - } - } - double end_sec = gettime(); - printf("\b\b\bok! finished in %.1fs\n", end_sec - start_sec); - consoleUpdate(NULL); - } - } - - // Deinitialize and clean up resources used by the console (important!) - consoleExit(NULL); - return 0; -} \ No newline at end of file + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include // for int64_t etc + + #include "types.h" + #include "sizes.h" + #include "tests.h" + #include + + /* Some helpful typedefs used throughout the file (used by original code) */ + typedef unsigned long long ull; + typedef unsigned long ul; + + /* number of bits in a machine word printed in the header */ + #define MACHINE_BITS ((int)(sizeof(void*) * 8)) + + PadState pad; + unsigned short dividend = 1; + + void waitForAnyKey() { + while (appletMainLoop()) + { + padUpdate(&pad); + + u64 kDown = padGetButtonsDown(&pad); + + if (kDown) + break; + + consoleUpdate(NULL); + } + } + + void ShowErr(const char* err, const char* details, Result rc) { + AppletStorage errStor; + LibAppletArgs args; + AppletHolder currentApplet; + + appletCreateLibraryApplet(¤tApplet, AppletId_LibraryAppletError, LibAppletMode_AllForeground); + libappletArgsCreate(&args, 1); + libappletArgsPush(&args, ¤tApplet); + appletCreateStorage(&errStor, 0x1018); + u8 argBuf[0x1018] = {0}; + argBuf[0] = 1; + + /* keep existing packing used by original code */ + *(u64*)&argBuf[8] = (((rc & 0x1ffu) + 2000) | (((rc >> 9) & 0x1fff & 0x1fffll) << 32)); + strcpy((char*) &argBuf[24], err); + strcpy((char*) &argBuf[0x818], details); + appletStorageWrite(&errStor, 0, argBuf, 0x1018); + appletHolderPushInData(¤tApplet, &errStor); + + appletHolderStart(¤tApplet); + appletHolderJoin(¤tApplet); + appletHolderClose(¤tApplet); + appletHolderRequestExit(¤tApplet); + } + + double gettime(void) + { + struct timeval tv; + gettimeofday(&tv, NULL); + return (double)((int64_t)tv.tv_sec * 1000000 + tv.tv_usec) / 1000000.; + } + + struct test tests[] = { + { "Random Value", test_random_value }, + { "Compare XOR", test_xor_comparison }, + { "Compare SUB", test_sub_comparison }, + { "Compare MUL", test_mul_comparison }, + { "Compare DIV", test_div_comparison }, + { "Compare OR", test_or_comparison }, + { "Compare AND", test_and_comparison }, + { "Sequential Increment", test_seqinc_comparison }, + { "Solid Bits", test_solidbits_comparison }, + { "Block Sequential", test_blockseq_comparison }, + { "Checkerboard", test_checkerboard_comparison }, + { "Bit Spread", test_bitspread_comparison }, + { "Bit Flip (Slow)", test_bitflip_comparison }, + { "Walking Ones", test_walkbits1_comparison }, + { "Walking Zeroes", test_walkbits0_comparison }, + #ifdef TEST_NARROW_WRITES + { "8-bit Writes", test_8bit_wide_random }, + { "16-bit Writes", test_16bit_wide_random }, + #endif + { NULL, NULL } + }; + + struct test stress_tests[] = { + { "Stress memcpy x128", test_stress_memcpy }, + { "Stress memset x128", test_stress_memset }, + { "Stress memcmp x 32", test_stress_memcmp }, + { NULL, NULL } + }; + + int memtester_pagesize(void) { + printf("using pagesize of 4096\n"); + return 4096; + } + + /* Global vars - so tests have access to this information */ + int use_phys = 0; + off_t physaddrbase = 0; + int testJobId[4] = {0}; + int testWorkerReport[4] = {0}; + size_t bufsize[4], wantbytes[4]; + void volatile *aligned[4]; + Thread threads[5]; + struct test* test_select = tests; + + void testWorker(int div) + { + /* Wait until main sets this worker to ready (-2) */ + while (testJobId[div] != -2) + svcSleepThread(10000000ULL); + + while (true) + { + int currentJobId = -1; + + /* Wait until main moves us to the stuck-address job (-1) */ + while (testJobId[div] != currentJobId) + svcSleepThread(10000000ULL); + + /* Stuck address test: bufsize is in bytes, test_stuck_address expects count in ul units */ + if (!test_stuck_address(aligned[div], bufsize[div] / sizeof(ul))) + { + testWorkerReport[div] = 1; + currentJobId++; + } + else + { + testWorkerReport[div] = -1; + return; + } + + /* Now iterate over the selected tests */ + while (test_select[currentJobId].name) + { + while (testJobId[div] != currentJobId) + svcSleepThread(10000000ULL); + + /* Ensure second pointer argument is a pointer (not integer) */ + void volatile *second_ptr = (void volatile *)((size_t)aligned[div] + bufsize[div] / 2); + int test_rc = test_select[currentJobId].fp(aligned[div], second_ptr, (bufsize[div] / sizeof(ul)) / 2); + if (!test_rc) + { + testWorkerReport[div] = 1; + currentJobId++; + } + else + { + testWorkerReport[div] = -1; + return; + } + } + } + } + + void testWorker0(void*) { testWorker(0); } + void testWorker1(void*) { testWorker(1); } + void testWorker2(void*) { testWorker(2); } + void testWorker3(void*) { testWorker(3); } + + void* workers[] = { + testWorker0, + testWorker1, + testWorker2, + testWorker3, + }; + + void LblUpdate() + { + smInitialize(); + lblInitialize(); + LblBacklightSwitchStatus lblstatus = LblBacklightSwitchStatus_Disabled; + lblGetBacklightSwitchStatus(&lblstatus); + if (lblstatus) { + lblSwitchBacklightOff(0); + } else { + lblSwitchBacklightOn(0); + } + lblExit(); + smExit(); + } + + void keyListener() + { + while (true) + { + padUpdate(&pad); + u64 kDown = padGetButtonsDown(&pad); + if (kDown & HidNpadButton_Minus) + { + LblUpdate(); + } + svcSleepThread(10000000ULL); + } + } + + // Main program entrypoint + int main(int argc, char* argv[]) + { + if(appletGetAppletType() != AppletType_Application) { + ShowErr("Running in applet mode\nMemTesterNX requires full memory mode.\nPlease launch hbmenu by holding R on an APP (e.g. a game) NOT an applet (e.g. Gallery)", "", 0); + return 0; + } + + appletReportUserIsActive(); + + consoleInit(NULL); + + padConfigureInput(1, HidNpadStyleSet_NpadStandard); + + padInitializeDefault(&pad); + + ull loop; + size_t i; + unsigned short div, testThreads = 3; + size_t pagesize, wantraw, wantbytes_orig; + ptrdiff_t pagesizemask; + void volatile *buf[4]; + int memshift; + ull totalmem = 0; + int numOfMallocs = 0; + bool isDevKit8GB = false; + + printf("MemTesterNX version " __version__ " (%d-bit)\n"\ + "Based on memtester. Copyright (C) 2001-2020 Charles Cazabon, 2021 KazushiMe.\n"\ + "Licensed under the GNU General Public License version 2 (only).\n\n"\ + "Support full RAM test (up to 8GB) with 3-4 threads.\n"\ + "It will be looping forever until error occurs or user exits to HOME screen.\n\n"\ + "Press A: long test\n"\ + "Press X: fast test\n"\ + "Press Y: stress DRAM (memcpy, memset and memcmp)\n"\ + "Press any other key: exit\n\n", + MACHINE_BITS); + + while (appletMainLoop()) + { + padUpdate(&pad); + + u64 kDown = padGetButtonsDown(&pad); + + if (kDown & HidNpadButton_A) + { + break; + } + else if (kDown & HidNpadButton_X) + { + dividend = 4; + break; + } + else if (kDown & HidNpadButton_Y) + { + dividend = 16; + test_select = stress_tests; + break; + } + else if (kDown) + { + consoleExit(NULL); + exit(0); + } + + consoleUpdate(NULL); + } + + // Disable auto sleep and request CPU Boost mode + appletSetAutoSleepDisabled(true); + appletSetCpuBoostMode(ApmCpuBoostMode_FastLoad); + + pagesize = memtester_pagesize(); + pagesizemask = (ptrdiff_t) ~(pagesize - 1); + printf("pagesizemask is 0x%tx\n", pagesizemask); + consoleUpdate(NULL); + + memshift = 20; /* megabytes */ + wantraw = 2048; // HOS limit + + wantbytes_orig = ((size_t) wantraw << memshift); + + // Allocate as much RAM as possible. + for (div = 0; div <= 3; div++) + { + buf[div] = NULL; + wantbytes[div] = wantbytes_orig; + + while (!buf[div] && wantbytes[div]) { + buf[div] = (void volatile *) malloc(wantbytes[div]); + if (!buf[div]) + wantbytes[div] -= pagesize; + } + + totalmem += wantbytes[div]; + + if ((wantbytes[div] >> memshift) < 2047) + { + numOfMallocs = div + 1; + break; + } + } + + for (div = 0; div < numOfMallocs; div++) + { + free((void *)buf[div]); + } + + // Unknown: Not sure if devkit could use full 8GB in application space + if ((totalmem >> memshift) > 3 * 2047) + { + isDevKit8GB = true; + testThreads = 4; + } + + // Create workers + for (div = 0; div < testThreads; div++) + { + Result rc; + rc = threadCreate(&threads[div], workers[div], NULL, NULL, 0x1000, 0x2C, div == 3 ? -2 : div); + if (R_FAILED(rc)) + { + printf("Fatal: threadCreate[%d] failed: 0x%X\n", div, rc); + consoleUpdate(NULL); + } + else + { + totalmem -= 0x1000; + } + } + + // keyListener + { + const int kl = testThreads; + Result rc = threadCreate(&threads[kl], keyListener, NULL, NULL, 0x1000, 0x20, -2); + if (R_FAILED(rc)) + { + printf("Fatal: threadCreate[%d] failed: 0x%X\n", kl, rc); + consoleUpdate(NULL); + } + threadStart(&threads[kl]); + } + + printf("\nTotal RAM available: %lluMB\n\n", (unsigned long long)(totalmem >> memshift)); + consoleUpdate(NULL); + + // Redistribute RAM allocation equally to testThreads workers + for (div = 0; div < testThreads; div++) + { + buf[div] = NULL; + if (isDevKit8GB) + { + if (div != 3) + wantbytes[div] = totalmem / 3; + else + wantbytes[div] = 2047 << memshift; /* convert MB to bytes */ + } + else + { + wantbytes[div] = totalmem / testThreads; + } + + while (!buf[div] && wantbytes[div]) { + buf[div] = (void volatile *) malloc(wantbytes[div]); + if (!buf[div]) + wantbytes[div] -= pagesize; + } + + bufsize[div] = wantbytes[div]; + + /* Do alignment here as well */ + if ((size_t) buf[div] % pagesize) { + aligned[div] = (void volatile *) (((size_t) buf[div] & pagesizemask) + pagesize); + bufsize[div] -= ((size_t) aligned[div] - (size_t) buf[div]); + } else { + aligned[div] = buf[div]; + } + + printf("Alloc %d: got %lluMB (%llu bytes)\n", div+1, (unsigned long long)(wantbytes[div] >> memshift), (unsigned long long)wantbytes[div]); + consoleUpdate(NULL); + } + + // Start workers + for (div = 0; div < testThreads; div++) + { + Result rc; + rc = threadStart(&threads[div]); + if (R_FAILED(rc)) + { + printf("Fatal: threadStart[%d] failed: 0x%X\n", div, rc); + consoleUpdate(NULL); + } + } + + for(loop=1;;loop++) + { + // Set testJobId to -2 (Ready) + for (int j = 0; j < testThreads; j++) + testJobId[j] = -2; + + printf("Loop %llu:\n", (unsigned long long)loop); + + // Stuck address (-1) + printf(" %-20s: ", "Stuck Address"); + consoleUpdate(NULL); + for (int j = 0; j < testThreads; j++) + testJobId[j] = -1; + + for (int j = 0; j < testThreads; ) + { + switch (testWorkerReport[j]) + { + case 0: + svcSleepThread(10000000ULL); + break; + case -1: + printf("Alloc %d/%d: Error detected!\nPress any key to exit.\n", j+1, testThreads); + consoleUpdate(NULL); + waitForAnyKey(); + consoleExit(NULL); + return 0; + case 1: + testWorkerReport[j] = 0; + j++; + continue; + } + } + printf("ok\n"); + consoleUpdate(NULL); + + // tests[] + for (i = 0 ;; i++) { + if (!test_select[i].name) + break; + + printf(" %-20s: ...", test_select[i].name); + consoleUpdate(NULL); + for (int j = 0; j < testThreads; j++) + testJobId[j] = (int)i; + + double start_sec = gettime(); + for (int j = 0; j < testThreads; ) + { + switch (testWorkerReport[j]) + { + case 0: + svcSleepThread(10000000ULL); + continue; + case -1: + printf("Alloc %d/%d: Error detected!\nPress any key to exit.\n", j+1, testThreads); + consoleUpdate(NULL); + waitForAnyKey(); + consoleExit(NULL); + return 0; + case 1: + testWorkerReport[j] = 0; + j++; + continue; + } + } + double end_sec = gettime(); + printf("\b\b\bok! finished in %.1fs\n", end_sec - start_sec); + consoleUpdate(NULL); + } + } + + // Deinitialize and clean up resources used by the console (important!) + consoleExit(NULL); + return 0; + } + \ No newline at end of file diff --git a/Source/OnDeviceConfig/include/defaults.hpp b/Source/OnDeviceConfig/include/defaults.hpp index 85a760a7..2416e55e 100644 --- a/Source/OnDeviceConfig/include/defaults.hpp +++ b/Source/OnDeviceConfig/include/defaults.hpp @@ -25,10 +25,6 @@ public: data.marikoGpuUV = 0; data.eristaCpuUV = 0; data.eristaGpuUV = 0; - data.enableMarikoGpuUnsafeFreqs = 0; - data.enableEristaGpuUnsafeFreqs = 0; - data.enableMarikoCpuUnsafeFreqs = 0; - data.enableEristaCpuUnsafeFreqs = 0; data.commonGpuVoltOffset = 0; data.marikoEmcDvbShift = 0; diff --git a/Source/OnDeviceConfig/include/kip_handler.hpp b/Source/OnDeviceConfig/include/kip_handler.hpp index 888b343d..9e1b55ca 100644 --- a/Source/OnDeviceConfig/include/kip_handler.hpp +++ b/Source/OnDeviceConfig/include/kip_handler.hpp @@ -28,10 +28,6 @@ private: uint32_t marikoGpuUV; uint32_t eristaCpuUV; uint32_t eristaGpuUV; - uint32_t enableMarikoGpuUnsafeFreqs; - uint32_t enableEristaGpuUnsafeFreqs; - uint32_t enableMarikoCpuUnsafeFreqs; - uint32_t enableEristaCpuUnsafeFreqs; uint32_t commonGpuVoltOffset; uint32_t marikoEmcDvbShift; diff --git a/Source/OnDeviceConfig/source/kip_handler.cpp b/Source/OnDeviceConfig/source/kip_handler.cpp index cda730f6..60205199 100644 --- a/Source/OnDeviceConfig/source/kip_handler.cpp +++ b/Source/OnDeviceConfig/source/kip_handler.cpp @@ -60,10 +60,6 @@ bool KipHandler::readKip() { data.marikoGpuUV = readU32(); data.eristaCpuUV = readU32(); data.eristaGpuUV = readU32(); - data.enableMarikoGpuUnsafeFreqs = readU32(); - data.enableEristaGpuUnsafeFreqs = readU32(); - data.enableMarikoCpuUnsafeFreqs = readU32(); - data.enableEristaCpuUnsafeFreqs = readU32(); data.commonGpuVoltOffset = readU32(); data.marikoEmcDvbShift = readU32(); @@ -179,10 +175,6 @@ bool KipHandler::writeKip() { writeU32(data.marikoGpuUV); writeU32(data.eristaCpuUV); writeU32(data.eristaGpuUV); - writeU32(data.enableMarikoGpuUnsafeFreqs); - writeU32(data.enableEristaGpuUnsafeFreqs); - writeU32(data.enableMarikoCpuUnsafeFreqs); - writeU32(data.enableEristaCpuUnsafeFreqs); writeU32(data.commonGpuVoltOffset); writeU32(data.marikoEmcDvbShift); diff --git a/Source/OnDeviceConfig/source/ui.cpp b/Source/OnDeviceConfig/source/ui.cpp index 4efd7255..09b4730d 100644 --- a/Source/OnDeviceConfig/source/ui.cpp +++ b/Source/OnDeviceConfig/source/ui.cpp @@ -111,8 +111,6 @@ void UI::renderGPUMenu() { auto& data = kipHandler->getData(); std::vector menuItems = { - "Enable Unsafe Frequencies (Mariko): " + std::string(data.enableMarikoGpuUnsafeFreqs ? "ON" : "OFF"), - "Enable Unsafe Frequencies (Erista): " + std::string(data.enableEristaGpuUnsafeFreqs ? "ON" : "OFF"), "Mariko GPU vMin: " + (data.marikoGpuVmin == 0 ? "Disabled" : std::to_string(data.marikoGpuVmin) + "mV"), "Mariko GPU vMax: " + (data.marikoGpuVmax == 0 ? "Disabled" : std::to_string(data.marikoGpuVmax) + "mV"), "Erista GPU vMin: " + (data.eristaGpuVmin == 0 ? "Disabled" : std::to_string(data.eristaGpuVmin) + "mV"), @@ -144,8 +142,6 @@ void UI::renderCPUMenu() { auto& data = kipHandler->getData(); std::vector menuItems = { - "Enable Unsafe Frequencies (Mariko): " + std::string(data.enableMarikoCpuUnsafeFreqs ? "ON" : "OFF"), - "Enable Unsafe Frequencies (Erista): " + std::string(data.enableEristaCpuUnsafeFreqs ? "ON" : "OFF"), "CPU Boost Frequency: " + std::to_string(data.commonCpuBoostClock / 1000) + " MHz", "Mariko CPU vMin: " + (data.marikoCpuVmin == 0 ? "Default" : std::to_string(data.marikoCpuVmin) + "mV"), "Mariko CPU vMax: " + (data.marikoCpuMaxVolt == 0 ? "Disabled" : std::to_string(data.marikoCpuMaxVolt) + "mV"), @@ -346,28 +342,6 @@ void UI::handleGPUMenuInput(u64 kDown) { auto& data = kipHandler->getData(); switch (selectedIndex) { - case 0: { // Mariko GPU Unsafe Freqs - std::vector opts = {"Disabled (0)", "Enabled (1)"}; - showValueEditor("Enable Unsafe GPU Frequencies (Mariko)", EditorType::LIST, - data.enableMarikoGpuUnsafeFreqs, - [this, &data](int val) { - data.enableMarikoGpuUnsafeFreqs = val; - if (autoSave && kipHandler) kipHandler->writeKip(); - setStatus("Mariko GPU unsafe: " + std::string(val ? "ENABLED" : "DISABLED")); - }, opts); - break; - } - case 1: { // Erista GPU Unsafe Freqs - std::vector opts = {"Disabled (0)", "Enabled (1)"}; - showValueEditor("Enable Unsafe GPU Frequencies (Erista)", EditorType::LIST, - data.enableEristaGpuUnsafeFreqs, - [this, &data](int val) { - data.enableEristaGpuUnsafeFreqs = val; - if (autoSave && kipHandler) kipHandler->writeKip(); - setStatus("Erista GPU unsafe: " + std::string(val ? "ENABLED" : "DISABLED")); - }, opts); - break; - } case 5: { // Mariko GPU UV std::vector opts = {"UV0 (No Table)", "UV1 (Regular)", "UV2 (High)", "UV3 (Custom)"}; showValueEditor("Mariko GPU Undervolt Mode", EditorType::LIST, @@ -418,28 +392,6 @@ void UI::handleCPUMenuInput(u64 kDown) { auto& data = kipHandler->getData(); switch (selectedIndex) { - case 0: { // Mariko CPU Unsafe - std::vector opts = {"Disabled (0)", "Enabled (1)"}; - showValueEditor("Enable Unsafe CPU Frequencies (Mariko)", EditorType::LIST, - data.enableMarikoCpuUnsafeFreqs, - [this, &data](int val) { - data.enableMarikoCpuUnsafeFreqs = val; - if (autoSave && kipHandler) kipHandler->writeKip(); - setStatus("Mariko CPU unsafe: " + std::string(val ? "ENABLED" : "DISABLED")); - }, opts); - break; - } - case 1: { // Erista CPU Unsafe - std::vector opts = {"Disabled (0)", "Enabled (1)"}; - showValueEditor("Enable Unsafe CPU Frequencies (Erista)", EditorType::LIST, - data.enableEristaCpuUnsafeFreqs, - [this, &data](int val) { - data.enableEristaCpuUnsafeFreqs = val; - if (autoSave && kipHandler) kipHandler->writeKip(); - setStatus("Erista CPU unsafe: " + std::string(val ? "ENABLED" : "DISABLED")); - }, opts); - break; - } default: setStatus("Feature in development"); break; diff --git a/Source/TimingTool/Downloads.zip b/Source/TimingTool/Downloads.zip new file mode 100644 index 00000000..39d16978 Binary files /dev/null and b/Source/TimingTool/Downloads.zip differ diff --git a/Source/TimingTool/README.md b/Source/TimingTool/README.md new file mode 100644 index 00000000..6833db45 --- /dev/null +++ b/Source/TimingTool/README.md @@ -0,0 +1,5 @@ +# Horizon OC TimingTool + +A simple tool to dump timings from Linux and scale them + +(c) 2025 Souldbminer & Horizon OC Contributors \ No newline at end of file diff --git a/Source/TimingTool/assets/Lexend.ttf b/Source/TimingTool/assets/Lexend.ttf new file mode 100644 index 00000000..2516b002 Binary files /dev/null and b/Source/TimingTool/assets/Lexend.ttf differ diff --git a/Source/TimingTool/build.bat b/Source/TimingTool/build.bat new file mode 100644 index 00000000..c7f25909 --- /dev/null +++ b/Source/TimingTool/build.bat @@ -0,0 +1,2 @@ +python -m PyInstaller --onefile --add-data "assets;assets" --noconsole src/main.py +move "dist\main.exe" "dist\timingtool.exe" diff --git a/Source/TimingTool/main.spec b/Source/TimingTool/main.spec new file mode 100644 index 00000000..009c249d --- /dev/null +++ b/Source/TimingTool/main.spec @@ -0,0 +1,38 @@ +# -*- mode: python ; coding: utf-8 -*- + + +a = Analysis( + ['src\\main.py'], + pathex=[], + binaries=[], + datas=[('assets', 'assets')], + hiddenimports=[], + hookspath=[], + hooksconfig={}, + runtime_hooks=[], + excludes=[], + noarchive=False, + optimize=0, +) +pyz = PYZ(a.pure) + +exe = EXE( + pyz, + a.scripts, + a.binaries, + a.datas, + [], + name='main', + debug=False, + bootloader_ignore_signals=False, + strip=False, + upx=True, + upx_exclude=[], + runtime_tmpdir=None, + console=False, + disable_windowed_traceback=False, + argv_emulation=False, + target_arch=None, + codesign_identity=None, + entitlements_file=None, +) diff --git a/Source/TimingTool/run.bat b/Source/TimingTool/run.bat new file mode 100644 index 00000000..b3642477 --- /dev/null +++ b/Source/TimingTool/run.bat @@ -0,0 +1 @@ +python src/main.py \ No newline at end of file diff --git a/Source/TimingTool/src/main.py b/Source/TimingTool/src/main.py new file mode 100644 index 00000000..b2bb8bbe --- /dev/null +++ b/Source/TimingTool/src/main.py @@ -0,0 +1,420 @@ +""" + +HOC Timing Tool + +Copyright (C) Souldbminer + +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 that 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 . + +""" + +import zipfile +import tempfile +from pathlib import Path +import re +import dearpygui.dearpygui as dpg +import numpy as np +import os +import sys +from scipy.signal import savgol_filter + +REGISTER_RE = re.compile(r"^(emc|mc)_[A-Za-z0-9_]+\s+0x[0-9A-Fa-f]+$") +if getattr(sys, 'frozen', False): + assets_path = os.path.join(sys._MEIPASS, 'assets/') +else: + assets_path = os.path.join(os.path.dirname(__file__), '../assets/') + +def safe_r2(y, y_fit): + ss_res = np.sum((y - y_fit) ** 2) + ss_tot = np.sum((y - np.mean(y)) ** 2) + if ss_tot == 0: + return 0.0 + return max(0.0, 1 - ss_res / ss_tot) + +def find_inflection_points(x, y): + x = np.array(x, dtype=float) + y = np.array(y, dtype=float) + + if len(x) < 3: + return [] + + dx = np.diff(x) + dy = np.diff(y) + slopes = dy / dx + + slope_changes = np.abs(np.diff(slopes)) + + if len(slope_changes) > 0: + threshold = np.percentile(slope_changes, 40) + else: + return [] + + inflections = [] + for i in range(len(slope_changes)): + if slope_changes[i] > threshold: + inflections.append(i + 1) + + inflections = sorted(set(inflections)) + + if len(inflections) < 2 and len(slope_changes) > 0: + threshold = np.percentile(slope_changes, 60) + inflections = [] + for i in range(len(slope_changes)): + if slope_changes[i] > threshold: + inflections.append(i + 1) + inflections = sorted(set(inflections)) + + return inflections + +def fit_piecewise_segments(x, y, reg_name="register"): + x = np.array(x, dtype=float) + y = np.array(y, dtype=float) + + if len(x) < 3: + return None + + inflections = find_inflection_points(x, y) + + breakpoints = [0] + inflections + [len(x) - 1] + breakpoints = sorted(set(breakpoints)) + + segments = [] + thresholds = [] + slopes = [] + intercepts = [] + + for i in range(len(breakpoints) - 1): + start_idx = breakpoints[i] + end_idx = breakpoints[i + 1] + + x_seg = x[start_idx:end_idx + 1] + y_seg = y[start_idx:end_idx + 1] + + if len(x_seg) < 2: + continue + + try: + p = np.polyfit(x_seg, y_seg, 1) + slope, intercept = p[0], p[1] + + thresholds.append(x[end_idx]) + slopes.append(slope) + intercepts.append(intercept) + except Exception: + continue + + if not thresholds: + return None + + def piecewise(t, thresholds_list=thresholds, slopes_list=slopes, intercepts_list=intercepts): + if np.isscalar(t): + for thresh, slp, intcpt in zip(thresholds_list, slopes_list, intercepts_list): + if t <= thresh: + return slp * t + intcpt + return slopes_list[-1] * t + intercepts_list[-1] + else: + result = np.zeros_like(t, dtype=float) + for i, ti in enumerate(t): + for thresh, slp, intcpt in zip(thresholds_list, slopes_list, intercepts_list): + if ti <= thresh: + result[i] = slp * ti + intcpt + break + else: + result[i] = slopes_list[-1] * ti + intercepts_list[-1] + return result + + y_fit = piecewise(x) + r2 = safe_r2(y, y_fit) + + formula_lines = [] + for i, (thresh, slp, intcpt) in enumerate(zip(thresholds, slopes, intercepts)): + if abs(slp) < 1e-6: + val_str = f"{intcpt:.0f}" + else: + slp_simple = round(slp, 4) + intcpt_simple = round(intcpt, 0) + if slp_simple == int(slp_simple): + slp_simple = int(slp_simple) + if intcpt_simple >= 0: + val_str = f"{slp_simple} * x + {intcpt_simple}" + else: + val_str = f"{slp_simple} * x - {abs(intcpt_simple)}" + + if i == len(thresholds) - 1: + formula_lines.append(f" return {val_str};") + else: + formula_lines.append(f" if (x <= {thresh:.0f}) return {val_str};") + + formula = "float timing(float x) {\n" + "\n".join(formula_lines) + "\n}" + + advanced_lines = [] + max_freq = max(x) if len(x) > 0 else 0 + + for i, (thresh, slp, intcpt) in enumerate(zip(thresholds, slopes, intercepts)): + if abs(slp) < 1e-6: + val = f"{intcpt:.0f}" + else: + slp_simple = round(slp, 4) + intcpt_simple = round(intcpt, 0) + if slp_simple == int(slp_simple): + slp_simple = int(slp_simple) + if intcpt_simple >= 0: + val = f"({slp_simple} * freq + {intcpt_simple})" + else: + val = f"({slp_simple} * freq - {abs(intcpt_simple)})" + + if thresh >= max_freq - 1: + advanced_lines.append(f"WRITE_ALL_PARAM_REG(EMC_{reg_name}, {val});") + elif i == 0: + advanced_lines.append(f"if (freq <= {thresh:.0f}) {{") + advanced_lines.append(f" WRITE_ALL_PARAM_REG(EMC_{reg_name}, {val});") + advanced_lines.append("}") + else: + advanced_lines.append(f"else if (freq <= {thresh:.0f}) {{") + advanced_lines.append(f" WRITE_ALL_PARAM_REG(EMC_{reg_name}, {val});") + advanced_lines.append("}") + + advanced_formula = "\n".join(advanced_lines) + + return { + 'fn': piecewise, + 'formula': formula, + 'advanced_formula': advanced_formula, + 'r2': r2, + 'thresholds': thresholds, + 'slopes': slopes, + 'intercepts': intercepts, + 'reg_name': reg_name + } + + +def parse_dump_file(path: Path): + registers = {} + try: + for line in path.read_text(errors="ignore").splitlines(): + line = line.strip() + if not line or line.startswith("#"): + continue + parts = line.split() + if len(parts) < 2: + continue + name, val = parts[0], parts[-1] + if not (name.lower().startswith("emc_") or name.lower().startswith("mc_")): + continue + if not val.startswith("0x"): + continue + try: + registers[name] = int(val, 16) + except ValueError: + pass + except Exception: + pass + return registers + + +def analyze_zip(zip_path: Path): + tmpdir = Path(tempfile.mkdtemp(prefix="timingtool_extract_")) + with zipfile.ZipFile(zip_path, "r") as z: + z.extractall(tmpdir) + + results = {} + for base_dir in tmpdir.iterdir(): + if not base_dir.is_dir(): + continue + base_latency = base_dir.name + results.setdefault(base_latency, {"mc": {}, "emc": {}}) + + for typ in ("mc", "emc"): + folder = base_dir / typ + if not folder.exists(): + continue + for dump in folder.glob("*.txt"): + m = re.search(r"(\d+)", dump.name) + if not m: + continue + freq = int(m.group(1)) + registers = parse_dump_file(dump) + for reg, val in registers.items(): + results[base_latency][typ].setdefault(reg, {})[freq] = val + + return results + + + +dpg.create_context() +dpg.create_viewport(title="Horizon OC Timing Tool", width=1920, height=1080) +dpg.maximize_viewport() + +with dpg.font_registry(): + lexend = dpg.add_font(assets_path + "Lexend.ttf", 16) + +with dpg.window(label="HOC Timing Tool", width=1920, height=1080, tag="main_window"): + with dpg.tab_bar(tag="root_tabs"): + with dpg.tab(label=" File", tag="file_tab"): + dpg.add_text("Timing Analyzer\nSelect a ZIP file structured as:\n//_mc.txt") + dpg.add_button(label="Select ZIP File...", callback=lambda s,a: dpg.show_item("file_dialog")) + dpg.add_separator() + dpg.add_text("Status:") + dpg.add_text("Waiting...", tag="status_text") + + with dpg.tab(label="Graphs", tag="graph_tab"): + with dpg.tab_bar(tag="main_tabs"): + dpg.add_tab(label="No Data", tag="placeholder_tab") + + with dpg.tab(label="Code", tag="code_tab"): + with dpg.tab_bar(tag="code_tabs"): + dpg.add_tab(label="No Data", tag="code_placeholder_tab") + + +def handle_file_selection(sender, app_data): + if not app_data["selections"]: + return + zip_path = list(app_data["selections"].values())[0] + dpg.set_value("status_text", f"Analyzing {zip_path} ...") + try: + data = analyze_zip(Path(zip_path)) + except Exception as e: + dpg.set_value("status_text", f"Error: {e}") + return + + dpg.delete_item("main_tabs", children_only=True) + + if not data: + dpg.add_tab(label="No valid data", parent="main_tabs") + dpg.set_value("status_text", "No valid data found in ZIP.") + return + + dpg.delete_item("code_tabs", children_only=True) + + for base_latency, lat_data in sorted(data.items()): + with dpg.tab(label=f"{base_latency}bl", parent="main_tabs"): + with dpg.tab_bar(): + for typ in ("mc", "emc"): + with dpg.tab(label=typ.upper()): + if not lat_data[typ]: + dpg.add_text(f"No {typ.upper()} data.") + continue + + search_tag = f"search_{base_latency}_{typ}" + dpg.add_input_text(label="Search Timings", tag=search_tag, width=500) + + with dpg.child_window(width=-1, height=850, horizontal_scrollbar=True) as scroll_area: + for reg_name, freq_map in sorted(lat_data[typ].items()): + freqs = sorted(freq_map.keys()) + vals = [freq_map[f] for f in freqs] + if len(freqs) < 2: + continue + + x = np.array(freqs, dtype=float) + y = np.array(vals, dtype=float) + + fit_result = fit_piecewise_segments(x, y, reg_name) + + if fit_result is None: + continue + + plot_tag = f"{base_latency}_{typ}_{reg_name}_plot" + container_tag = f"{plot_tag}_container" + dropdown_tag = f"{plot_tag}_dropdown" + value_tag = f"{plot_tag}_value" + + with dpg.group(tag=container_tag): + with dpg.plot(label=reg_name, height=250, width=-1): + dpg.add_plot_legend() + dpg.add_plot_axis(dpg.mvXAxis, label="Frequency (MHz)") + y_axis = dpg.add_plot_axis(dpg.mvYAxis, label="Register") + dpg.add_line_series(freqs, vals, label="Data", parent=y_axis) + + fit_x = np.linspace(min(freqs), max(freqs), 100) + fit_y = fit_result['fn'](fit_x) + dpg.add_line_series(fit_x, fit_y, label=f"Fit (R²={fit_result['r2']:.3f})", parent=y_axis) + + dpg.add_text(f"R² = {fit_result['r2']:.4f}", color=(100, 200, 100)) + + with dpg.tab_bar(): + with dpg.tab(label="Timing Function"): + dpg.add_input_text(default_value=fit_result['formula'], readonly=True, width=-1, height=150, multiline=True, tag=f"{container_tag}_formula") + with dpg.tab(label="Register Write"): + dpg.add_input_text(default_value=fit_result['advanced_formula'], readonly=True, width=-1, height=150, multiline=True, tag=f"{container_tag}_advanced") + + def make_freq_callback(freq_map, val_tag): + def _callback(sender, app_data): + freq = int(app_data) + val = freq_map.get(freq) + if val is not None: + dpg.set_value(val_tag, f"Value: 0x{val:08X} ({val})") + else: + dpg.set_value(val_tag, "Value: N/A") + return _callback + + dpg.add_combo( + items=[str(f) for f in freqs], + label="Select Frequency", + default_value=str(freqs[0]), + width=150, + callback=make_freq_callback(freq_map, value_tag), + tag=dropdown_tag + ) + dpg.add_text(f"Value: 0x{vals[0]:08X} ({vals[0]})", tag=value_tag) + + def make_filter_closure(scroll_area, search_tag, lat_data=lat_data[typ], base=base_latency, t=typ): + def _filter(sender, app_data): + query = app_data.strip().lower() + for reg_name in lat_data.keys(): + container_tag = f"{base}_{t}_{reg_name}_plot_container" + visible = query in reg_name.lower() if query else True + if dpg.does_item_exist(container_tag): + dpg.configure_item(container_tag, show=visible) + return _filter + + dpg.set_item_callback(search_tag, make_filter_closure(scroll_area, search_tag)) + + for base_latency, lat_data in sorted(data.items()): + code_content = "" + with dpg.tab(label=f"{base_latency}bl", parent="code_tabs"): + with dpg.tab_bar(): + for typ in ("mc", "emc"): + with dpg.tab(label=typ.upper()): + typ_code = "" + if lat_data[typ]: + for reg_name, freq_map in sorted(lat_data[typ].items()): + freqs = sorted(freq_map.keys()) + vals = [freq_map[f] for f in freqs] + if len(freqs) < 2: + continue + + x = np.array(freqs, dtype=float) + y = np.array(vals, dtype=float) + fit_result = fit_piecewise_segments(x, y, reg_name) + + if fit_result: + typ_code += fit_result['advanced_formula'] + "\n\n" + + if typ_code: + dpg.add_input_text(default_value=typ_code, readonly=True, width=-1, height=-1, multiline=True) + else: + dpg.add_text(f"No {typ.upper()} data.") + + dpg.set_value("status_text", "Done.") + + +with dpg.file_dialog(directory_selector=False, show=False, callback=handle_file_selection, tag="file_dialog", width=500, height=300, modal=True): + dpg.add_file_extension(".zip") + +dpg.set_primary_window("main_window", True) + +dpg.bind_font(lexend) +dpg.setup_dearpygui() +dpg.show_viewport() +dpg.start_dearpygui() +dpg.destroy_context() \ No newline at end of file diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/1600_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/1600_emc.txt new file mode 100644 index 00000000..c2b939a4 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/1600_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000060 +EMC_RFC_0 = 0x000001C0 +EMC_RAS_0 = 0x00000044 +EMC_RP_0 = 0x0000001D +EMC_R2W_0 = 0x00000029 +EMC_W2R_0 = 0x00000021 +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x0000001D +EMC_WR_RCD_0 = 0x0000001D +EMC_RRD_0 = 0x00000010 +EMC_REXT_0 = 0x00000017 +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000024 +EMC_QRST_0 = 0x0006000C +EMC_QSAFE_0 = 0x00000033 +EMC_RDV_0 = 0x00000039 +EMC_REFRESH_0 = 0x00001820 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000010 +EMC_PDEX2RD_0 = 0x00000010 +EMC_PCHG2PDEN_0 = 0x00000003 +EMC_ACT2PDEN_0 = 0x00000017 +EMC_AR2PDEN_0 = 0x00000003 +EMC_RW2PDEN_0 = 0x00000038 +EMC_TXSR_0 = 0x000001CC +EMC_TCKE_0 = 0x0000000D +EMC_TFAW_0 = 0x00000040 +EMC_TRPAB_0 = 0x00000022 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x00000014 +EMC_TREFBW_0 = 0x00001860 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000002E +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x01900017 +EMC_MRS_WAIT_CNT_0 = 0x0640002F +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012C0DC +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x0000000E +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D0000 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000014 +EMC_EINPUT_DURATION_0 = 0x0000001C +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000018 +EMC_TPD_0 = 0x0000000C +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x00110835 +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000003B +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x00000039 +EMC_RDV_EARLY_0 = 0x00000037 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x00310640 +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186190 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000039 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F070A +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000608 +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000308C +EMC_TXSRDLL_0 = 0x000001CC +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000002B +EMC_TR_RDV_MASK_0 = 0x0000003B +EMC_TR_QSAFE_0 = 0x00000033 +EMC_TR_QRST_0 = 0x0006000C +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E00309 +EMC_IBDLY_0 = 0x1000001C +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0B09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002B +EMC_QUSE_WIDTH_0 = 0x00000008 +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x000000E0 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000012 +EMC_CMD_BRLSHFT_3_0 = 0x00000012 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC4204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x0008000D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x000E0006 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x00210027 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x00200027 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00230026 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x0008000D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x000E0006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x00020007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x00080000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x00020007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x00080000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220023 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00240024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x001E0022 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x001F0022 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x2E2F2F2F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x2D2B292D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000002D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x2B2E2C2C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x2B2E292A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000029 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x32323333 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x2F313228 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000030 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x252C2D2B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x2A292623 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000028 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x2C2F2D2E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x2C2F2C2D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000002E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x2D2C2D2D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x2C2C2D2A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000002B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x37373735 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x34353134 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000032 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x2F2E2A2B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x2C2B2D29 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000002B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03050505 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x03000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x05050305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x06060709 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x06070700 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x01060707 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06040100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00050205 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02040306 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02000102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x00020001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05050504 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04020004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x04020003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x03020201 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x23232527 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x27272325 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x00080008 +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00060006 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x000E000E +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x0000000D +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x070A070A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x0000080D +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040320 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000B09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/1866_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/1866_emc.txt new file mode 100644 index 00000000..c774dbdc --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/1866_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000070 +EMC_RFC_0 = 0x0000020B +EMC_RAS_0 = 0x0000004F +EMC_RP_0 = 0x00000022 +EMC_R2W_0 = 0x0000002A +EMC_W2R_0 = 0x00000022 +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x00000022 +EMC_WR_RCD_0 = 0x00000022 +EMC_RRD_0 = 0x00000013 +EMC_REXT_0 = 0x0000001A +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000024 +EMC_QRST_0 = 0x00070008 +EMC_QSAFE_0 = 0x00000034 +EMC_RDV_0 = 0x0000003A +EMC_REFRESH_0 = 0x00001C2D +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000013 +EMC_PDEX2RD_0 = 0x00000013 +EMC_PCHG2PDEN_0 = 0x00000004 +EMC_ACT2PDEN_0 = 0x0000001B +EMC_AR2PDEN_0 = 0x00000004 +EMC_RW2PDEN_0 = 0x00000039 +EMC_TXSR_0 = 0x00000219 +EMC_TCKE_0 = 0x00000010 +EMC_TFAW_0 = 0x0000004B +EMC_TRPAB_0 = 0x00000028 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x00000017 +EMC_TREFBW_0 = 0x00001C6D +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000037 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x01D3001B +EMC_MRS_WAIT_CNT_0 = 0x074A0030 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80122A40 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000010 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000011 +EMC_EINPUT_DURATION_0 = 0x00000020 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000001C +EMC_TPD_0 = 0x0000000E +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D180000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000003C +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003A +EMC_RDV_EARLY_0 = 0x00000038 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x0039074A +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011861D3 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003A +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x0000070B +EMC_DYN_SELF_REF_CONTROL_0 = 0x80003873 +EMC_TXSRDLL_0 = 0x00000219 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000002C +EMC_TR_RDV_MASK_0 = 0x0000003C +EMC_TR_QSAFE_0 = 0x00000034 +EMC_TR_QRST_0 = 0x00070008 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030A +EMC_IBDLY_0 = 0x1000001B +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0B +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002C +EMC_QUSE_WIDTH_0 = 0x00000009 +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000106 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x88204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x0009000F +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00100007 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x00210028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x00200028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00230027 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x0009000F +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00100007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x00020008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x00090000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x00020008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x00090000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00240024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x001F0022 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00200023 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x393A3A3A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x39353337 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000038 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x37393737 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x35393235 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000034 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x3E3C3E3E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x3A3C3F32 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000024 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x30363736 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x35342F2D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000032 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x373B393B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x383B3838 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000003A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x37353737 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x2C2C2D2A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000036 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x42424341 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x3F413D3F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000003E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x3A393436 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x37353833 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000035 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04060506 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x05070307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x06060809 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x06060800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050706 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06040100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00040105 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02040006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02020303 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02020101 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05050503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04020004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x04040203 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x03030200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x25242526 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x2B262822 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x000F000F +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00060006 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00100010 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x0000000F +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x0000080F +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000403A5 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0B +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2133_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2133_emc.txt new file mode 100644 index 00000000..ec0e8a4c --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2133_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000080 +EMC_RFC_0 = 0x00000256 +EMC_RAS_0 = 0x0000005A +EMC_RP_0 = 0x00000027 +EMC_R2W_0 = 0x0000002B +EMC_W2R_0 = 0x00000025 +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x00000027 +EMC_WR_RCD_0 = 0x00000027 +EMC_RRD_0 = 0x00000010 +EMC_REXT_0 = 0x0000001A +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000024 +EMC_QRST_0 = 0x00070005 +EMC_QSAFE_0 = 0x00000035 +EMC_RDV_0 = 0x0000003B +EMC_REFRESH_0 = 0x0000203F +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000016 +EMC_PDEX2RD_0 = 0x00000016 +EMC_PCHG2PDEN_0 = 0x00000004 +EMC_ACT2PDEN_0 = 0x0000001E +EMC_AR2PDEN_0 = 0x00000004 +EMC_RW2PDEN_0 = 0x00000039 +EMC_TXSR_0 = 0x00000266 +EMC_TCKE_0 = 0x00000012 +EMC_TFAW_0 = 0x00000040 +EMC_TRPAB_0 = 0x0000002D +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001A +EMC_TREFBW_0 = 0x0000207F +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000003F +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x0216001E +EMC_MRS_WAIT_CNT_0 = 0x07FF0031 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80040101 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000013 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000E +EMC_EINPUT_DURATION_0 = 0x00000024 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000020 +EMC_TPD_0 = 0x00000010 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000003D +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003B +EMC_RDV_EARLY_0 = 0x00000039 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186216 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003B +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x0000080F +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004062 +EMC_TXSRDLL_0 = 0x00000266 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000002D +EMC_TR_RDV_MASK_0 = 0x0000003D +EMC_TR_QSAFE_0 = 0x00000035 +EMC_TR_QRST_0 = 0x00070005 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030B +EMC_IBDLY_0 = 0x1000001B +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0E0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002D +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000012B +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A01A018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x00210029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000A0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000A0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00240025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00250025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00200024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00230024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x45454546 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x43403E43 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000043 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x42444241 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x3F443C3F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000003D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x49474A49 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x4548493C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000047 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x38404140 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x3E3D3934 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000003B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00050304 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x00060102 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x413F4041 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x4141413E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000040 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x0E0E0F0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x0B0D080B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x44433E40 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x413E433D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000003E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03070706 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x060A0409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03070004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0708090B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x08080900 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06050000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00080406 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02050507 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03010204 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05040402 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06050205 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06020401 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x27262629 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x27292629 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00120012 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000012 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000812 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004042B +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000E0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2166_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2166_emc.txt new file mode 100644 index 00000000..fd21fdd3 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2166_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000082 +EMC_RFC_0 = 0x0000025F +EMC_RAS_0 = 0x0000005B +EMC_RP_0 = 0x00000027 +EMC_R2W_0 = 0x0000002B +EMC_W2R_0 = 0x00000025 +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x00000027 +EMC_WR_RCD_0 = 0x00000027 +EMC_RRD_0 = 0x00000011 +EMC_REXT_0 = 0x00000019 +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000025 +EMC_QRST_0 = 0x00070006 +EMC_QSAFE_0 = 0x00000036 +EMC_RDV_0 = 0x0000003C +EMC_REFRESH_0 = 0x000020BF +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000017 +EMC_PDEX2RD_0 = 0x00000017 +EMC_PCHG2PDEN_0 = 0x00000004 +EMC_ACT2PDEN_0 = 0x0000001F +EMC_AR2PDEN_0 = 0x00000004 +EMC_RW2PDEN_0 = 0x00000039 +EMC_TXSR_0 = 0x0000026F +EMC_TCKE_0 = 0x00000013 +EMC_TFAW_0 = 0x00000041 +EMC_TRPAB_0 = 0x0000002E +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001A +EMC_TREFBW_0 = 0x000020FF +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000040 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x021E001F +EMC_MRS_WAIT_CNT_0 = 0x07FF0031 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012AFC4 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000013 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000F +EMC_EINPUT_DURATION_0 = 0x00000024 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000021 +EMC_TPD_0 = 0x00000011 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000003E +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003C +EMC_RDV_EARLY_0 = 0x0000003A +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x0118621E +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003C +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x0000082F +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000415D +EMC_TXSRDLL_0 = 0x0000026F +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000002E +EMC_TR_RDV_MASK_0 = 0x0000003E +EMC_TR_QSAFE_0 = 0x00000036 +EMC_TR_QRST_0 = 0x00070006 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030B +EMC_IBDLY_0 = 0x1000001C +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002E +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000130 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x8C200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x00210029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000B0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000B0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00200023 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00210024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x47474747 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x45413F45 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000045 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x44464342 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x41463E40 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000003F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x49484A4A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x46484A3C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000047 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x39414242 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x403E3A36 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000003D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x01060306 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02060202 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x42414142 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x4241423F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000041 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x0E0F100E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x0C0E090C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x46443F41 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x4340443D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000040 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04070707 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04090309 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02070004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0807090B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07080800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00070908 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07050101 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00040207 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02040207 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03010204 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01030002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x06040302 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x04040003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x04020100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x25232828 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x29282623 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00120012 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000012 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000812 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004043B +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2200_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2200_emc.txt new file mode 100644 index 00000000..47e38a48 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2200_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000084 +EMC_RFC_0 = 0x00000268 +EMC_RAS_0 = 0x0000005D +EMC_RP_0 = 0x00000028 +EMC_R2W_0 = 0x0000002B +EMC_W2R_0 = 0x00000025 +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x00000028 +EMC_WR_RCD_0 = 0x00000028 +EMC_RRD_0 = 0x00000011 +EMC_REXT_0 = 0x00000019 +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000025 +EMC_QRST_0 = 0x00070006 +EMC_QSAFE_0 = 0x00000036 +EMC_RDV_0 = 0x0000003C +EMC_REFRESH_0 = 0x00002144 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000017 +EMC_PDEX2RD_0 = 0x00000017 +EMC_PCHG2PDEN_0 = 0x00000004 +EMC_ACT2PDEN_0 = 0x0000001F +EMC_AR2PDEN_0 = 0x00000004 +EMC_RW2PDEN_0 = 0x00000039 +EMC_TXSR_0 = 0x00000279 +EMC_TCKE_0 = 0x00000013 +EMC_TFAW_0 = 0x00000042 +EMC_TRPAB_0 = 0x0000002F +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001A +EMC_TREFBW_0 = 0x00002184 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000041 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x0226001F +EMC_MRS_WAIT_CNT_0 = 0x07FF0031 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80129FB3 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000013 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000F +EMC_EINPUT_DURATION_0 = 0x00000024 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000021 +EMC_TPD_0 = 0x00000011 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D180000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000003E +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003C +EMC_RDV_EARLY_0 = 0x0000003A +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186226 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003C +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000851 +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000425F +EMC_TXSRDLL_0 = 0x00000279 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000002E +EMC_TR_RDV_MASK_0 = 0x0000003E +EMC_TR_QSAFE_0 = 0x00000036 +EMC_TR_QRST_0 = 0x00070006 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x1000001C +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0D0B +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002E +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x0000024A +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000134 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A01A010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x8C200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0021002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000B0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x00080000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00200023 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x07080707 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x06020005 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x46474543 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x42473F41 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000040 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x4B494C4C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x474A4B3D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000024 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x3B434443 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x41403B37 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000003F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x03080507 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x04090405 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03010204 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x03020300 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000002 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x1111120F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x0E0F0B0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x47454042 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x4441453F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000041 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04070807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x03080307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x01060003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0807090B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x08080800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00060908 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07050000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00040207 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02040207 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02010305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05030402 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x05040104 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x05020201 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x27252729 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x27272624 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00120012 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000012 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000812 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004044C +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000D0B +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2233_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2233_emc.txt new file mode 100644 index 00000000..e3322890 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2233_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000086 +EMC_RFC_0 = 0x00000272 +EMC_RAS_0 = 0x0000005E +EMC_RP_0 = 0x00000029 +EMC_R2W_0 = 0x0000002B +EMC_W2R_0 = 0x00000026 +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x00000029 +EMC_WR_RCD_0 = 0x00000029 +EMC_RRD_0 = 0x00000011 +EMC_REXT_0 = 0x00000019 +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000025 +EMC_QRST_0 = 0x00070005 +EMC_QSAFE_0 = 0x00000036 +EMC_RDV_0 = 0x0000003C +EMC_REFRESH_0 = 0x000021C5 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000017 +EMC_PDEX2RD_0 = 0x00000017 +EMC_PCHG2PDEN_0 = 0x00000004 +EMC_ACT2PDEN_0 = 0x00000020 +EMC_AR2PDEN_0 = 0x00000004 +EMC_RW2PDEN_0 = 0x0000003A +EMC_TXSR_0 = 0x00000282 +EMC_TCKE_0 = 0x00000013 +EMC_TFAW_0 = 0x00000043 +EMC_TRPAB_0 = 0x0000002F +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001A +EMC_TREFBW_0 = 0x00002205 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000042 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x022F0020 +EMC_MRS_WAIT_CNT_0 = 0x07FF0031 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80040101 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000013 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000E +EMC_EINPUT_DURATION_0 = 0x00000025 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000022 +EMC_TPD_0 = 0x00000011 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000003E +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003C +EMC_RDV_EARLY_0 = 0x0000003A +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x0118622F +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003C +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000871 +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000435A +EMC_TXSRDLL_0 = 0x00000282 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000002E +EMC_TR_RDV_MASK_0 = 0x0000003E +EMC_TR_QSAFE_0 = 0x00000036 +EMC_TR_QRST_0 = 0x00070005 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x1000001C +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0D0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002E +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000252 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000139 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A01A010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002F +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000B0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000B0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210023 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x08090809 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x06030106 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x06080605 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x04080103 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000001 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x4D4B4E4E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x494D4E3F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000004A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x3B444544 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x42413C38 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000003F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x05090608 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x05090505 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000022 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x05030405 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x2C2C2D2A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x11131310 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x0F110C0E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x08080104 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x05020601 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000002 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04080806 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x05090409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02070004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0707090A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07070800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050908 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x08060100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00050206 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02050207 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03010305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01020001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05050503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04020005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x05040004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x05020300 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x2725272A +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x27282625 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00120012 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000012 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000812 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004045D +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000D0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2266_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2266_emc.txt new file mode 100644 index 00000000..cdc65772 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2266_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000088 +EMC_RFC_0 = 0x0000027B +EMC_RAS_0 = 0x00000060 +EMC_RP_0 = 0x00000029 +EMC_R2W_0 = 0x0000002B +EMC_W2R_0 = 0x00000026 +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x00000029 +EMC_WR_RCD_0 = 0x00000029 +EMC_RRD_0 = 0x00000011 +EMC_REXT_0 = 0x0000001A +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000025 +EMC_QRST_0 = 0x00070005 +EMC_QSAFE_0 = 0x00000036 +EMC_RDV_0 = 0x0000003C +EMC_REFRESH_0 = 0x00002245 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000017 +EMC_PDEX2RD_0 = 0x00000017 +EMC_PCHG2PDEN_0 = 0x00000004 +EMC_ACT2PDEN_0 = 0x00000020 +EMC_AR2PDEN_0 = 0x00000004 +EMC_RW2PDEN_0 = 0x0000003A +EMC_TXSR_0 = 0x0000028C +EMC_TCKE_0 = 0x00000013 +EMC_TFAW_0 = 0x00000044 +EMC_TRPAB_0 = 0x00000030 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001B +EMC_TREFBW_0 = 0x00002285 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000042 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02370020 +EMC_MRS_WAIT_CNT_0 = 0x07FF0031 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x88010054 +EMC_MRR_0 = 0x8012768A +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000014 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D00C0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000E +EMC_EINPUT_DURATION_0 = 0x00000025 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000022 +EMC_TPD_0 = 0x00000011 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000003E +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003C +EMC_RDV_EARLY_0 = 0x0000003A +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186237 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003C +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000891 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004455 +EMC_TXSRDLL_0 = 0x0000028C +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000002E +EMC_TR_RDV_MASK_0 = 0x0000003E +EMC_TR_QSAFE_0 = 0x00000036 +EMC_TR_QRST_0 = 0x00070005 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x1000001C +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0F0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002E +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000013E +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000B0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002F +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000B0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000B0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000B0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210023 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0A0B0A0A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x08040207 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x07090806 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x040A0203 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0E0C0F0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0A0E0F00 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x3C454745 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x2B2A2723 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000040 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x050A0709 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x060B0607 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x05040506 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x06050502 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x13141512 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x11120E0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x09080305 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06040702 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03080806 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x03000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x05090409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02070005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x06060709 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x08080900 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050808 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x05030000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00050306 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02040207 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03010305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02020102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05050504 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03010001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x03020003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x03020201 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x27252729 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x28282525 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x0000000B +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000813 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004046D +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000D0B +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2300_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2300_emc.txt new file mode 100644 index 00000000..f71632f9 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2300_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x0000008A +EMC_RFC_0 = 0x00000284 +EMC_RAS_0 = 0x00000061 +EMC_RP_0 = 0x0000002A +EMC_R2W_0 = 0x0000002C +EMC_W2R_0 = 0x00000026 +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x0000002A +EMC_WR_RCD_0 = 0x0000002A +EMC_RRD_0 = 0x00000012 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000024 +EMC_QRST_0 = 0x00070004 +EMC_QSAFE_0 = 0x00000037 +EMC_RDV_0 = 0x0000003C +EMC_REFRESH_0 = 0x000022CA +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000019 +EMC_PDEX2RD_0 = 0x00000019 +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000021 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x0000003A +EMC_TXSR_0 = 0x00000296 +EMC_TCKE_0 = 0x00000014 +EMC_TFAW_0 = 0x00000045 +EMC_TRPAB_0 = 0x00000031 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001B +EMC_TREFBW_0 = 0x0000230A +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000045 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x023F0021 +EMC_MRS_WAIT_CNT_0 = 0x07FF0032 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80125E72 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000014 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000D +EMC_EINPUT_DURATION_0 = 0x00000026 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000023 +EMC_TPD_0 = 0x00000012 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000003E +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003C +EMC_RDV_EARLY_0 = 0x0000003A +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x0118623F +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003C +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080A +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x000008B2 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004558 +EMC_TXSRDLL_0 = 0x00000296 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000002E +EMC_TR_RDV_MASK_0 = 0x0000003E +EMC_TR_QSAFE_0 = 0x00000037 +EMC_TR_QRST_0 = 0x00070004 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x1000001B +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0D09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002E +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000142 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x22004120 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002F +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000B0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000B0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00210025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0A0B0C0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x0A050309 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x090A0807 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x060B0305 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0F0E1011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0C0F1002 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x3D464746 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x44433E3A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000041 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x070C090B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x070C0708 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x2D2C2D2D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x07060704 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x14151613 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x11130F10 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x0B0A0406 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x08060903 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04080807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04010004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x050A0409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x06060709 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x08080800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050808 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06050000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00060206 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02040207 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02010304 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05040504 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04020003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x04040003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x05020100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x27252828 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x29272726 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00060006 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000013 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000813 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040320 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000D09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2333_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2333_emc.txt new file mode 100644 index 00000000..c18cefe8 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2333_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x0000008C +EMC_RFC_0 = 0x0000028E +EMC_RAS_0 = 0x00000062 +EMC_RP_0 = 0x0000002A +EMC_R2W_0 = 0x0000002C +EMC_W2R_0 = 0x00000027 +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x0000002A +EMC_WR_RCD_0 = 0x0000002A +EMC_RRD_0 = 0x00000012 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000024 +EMC_QRST_0 = 0x00070003 +EMC_QSAFE_0 = 0x00000038 +EMC_RDV_0 = 0x0000003C +EMC_REFRESH_0 = 0x0000234B +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000019 +EMC_PDEX2RD_0 = 0x00000019 +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000021 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x0000003A +EMC_TXSR_0 = 0x0000029F +EMC_TCKE_0 = 0x00000014 +EMC_TFAW_0 = 0x00000046 +EMC_TRPAB_0 = 0x00000031 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001B +EMC_TREFBW_0 = 0x0000238B +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000045 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02480021 +EMC_MRS_WAIT_CNT_0 = 0x07FF0032 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80124B5F +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000014 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000C +EMC_EINPUT_DURATION_0 = 0x00000027 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000023 +EMC_TPD_0 = 0x00000012 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000003E +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003C +EMC_RDV_EARLY_0 = 0x0000003A +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186248 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003C +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080A +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x000008D2 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004653 +EMC_TXSRDLL_0 = 0x0000029F +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000002E +EMC_TR_RDV_MASK_0 = 0x0000003E +EMC_TR_QSAFE_0 = 0x00000038 +EMC_TR_QRST_0 = 0x00070003 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x1000001B +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0E09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002E +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000147 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A01A010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC0200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002F +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000B0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000B0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00240027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00210025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0C0B0C0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x09060509 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x0A0B0A09 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x080C0506 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x100F1212 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0D101102 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x3F484948 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x4544403B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000043 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x080E0A0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x090E0909 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x08070808 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x09080805 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x16161815 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x13151012 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x0C0B0507 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x08060A04 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03040506 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x040B030B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03090005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x06060709 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x06060700 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00060808 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06050000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00050205 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02040306 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04020406 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x03030003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05030503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x05040004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x05020200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x2624292A +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x29262529 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000013 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000813 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004048F +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000E09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2366_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2366_emc.txt new file mode 100644 index 00000000..692ca3d6 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2366_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x0000008E +EMC_RFC_0 = 0x00000297 +EMC_RAS_0 = 0x00000064 +EMC_RP_0 = 0x0000002B +EMC_R2W_0 = 0x0000002C +EMC_W2R_0 = 0x00000027 +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x0000002B +EMC_WR_RCD_0 = 0x0000002B +EMC_RRD_0 = 0x00000012 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000026 +EMC_QRST_0 = 0x0006000C +EMC_QSAFE_0 = 0x00000037 +EMC_RDV_0 = 0x0000003D +EMC_REFRESH_0 = 0x000023CB +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000019 +EMC_PDEX2RD_0 = 0x00000019 +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000022 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x0000003A +EMC_TXSR_0 = 0x000002A9 +EMC_TCKE_0 = 0x00000014 +EMC_TFAW_0 = 0x00000047 +EMC_TRPAB_0 = 0x00000032 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001C +EMC_TREFBW_0 = 0x0000240B +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000046 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02500022 +EMC_MRS_WAIT_CNT_0 = 0x07FF0032 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80122A41 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000015 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000E +EMC_EINPUT_DURATION_0 = 0x00000026 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000024 +EMC_TPD_0 = 0x00000012 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D180000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430021 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000003F +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003D +EMC_RDV_EARLY_0 = 0x0000003B +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186250 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003D +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080A +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x000008F2 +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000474E +EMC_TXSRDLL_0 = 0x000002A9 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000002F +EMC_TR_RDV_MASK_0 = 0x0000003F +EMC_TR_QSAFE_0 = 0x00000037 +EMC_TR_QRST_0 = 0x00070005 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x1000001D +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0E0B +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002F +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000014C +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A00A010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC0200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00150009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230030 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00150009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000C0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000C0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0D0D0D0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x0B07050B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x0C0D0B0A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x090E0608 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x11111413 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0F121304 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x404A4A49 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x4746413C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000044 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x0A0E0C0E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0A0F0A0A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000000E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x0A080A0A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x0A090A06 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x17181916 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x14161213 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x0F0C0708 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x0B070C05 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04080807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x03080407 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02050003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0707090B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07080700 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050808 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06040000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070306 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02050307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03010405 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02020102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05030403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04020005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x05030104 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x05020303 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x26242429 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x25262325 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000013 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000813 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004049F +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000E0B +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2400_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2400_emc.txt new file mode 100644 index 00000000..692686d4 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2400_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000090 +EMC_RFC_0 = 0x000002A0 +EMC_RAS_0 = 0x00000065 +EMC_RP_0 = 0x0000002C +EMC_R2W_0 = 0x0000002C +EMC_W2R_0 = 0x00000027 +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x0000002C +EMC_WR_RCD_0 = 0x0000002C +EMC_RRD_0 = 0x00000012 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000026 +EMC_QRST_0 = 0x00070005 +EMC_QSAFE_0 = 0x00000037 +EMC_RDV_0 = 0x0000003D +EMC_REFRESH_0 = 0x00002450 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000019 +EMC_PDEX2RD_0 = 0x00000019 +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000022 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x0000003A +EMC_TXSR_0 = 0x000002B2 +EMC_TCKE_0 = 0x00000014 +EMC_TFAW_0 = 0x00000048 +EMC_TRPAB_0 = 0x00000033 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001C +EMC_TREFBW_0 = 0x00002490 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000047 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02580022 +EMC_MRS_WAIT_CNT_0 = 0x07FF0032 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80122D40 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000015 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000E +EMC_EINPUT_DURATION_0 = 0x00000026 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000024 +EMC_TPD_0 = 0x00000012 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000003F +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003D +EMC_RDV_EARLY_0 = 0x0000003B +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186258 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003D +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000914 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004850 +EMC_TXSRDLL_0 = 0x000002B2 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000002F +EMC_TR_RDV_MASK_0 = 0x0000003F +EMC_TR_QSAFE_0 = 0x00000037 +EMC_TR_QRST_0 = 0x00070005 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x1000001D +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0E0C +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002F +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000150 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x88204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000C0014 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0015000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230030 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0014 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0015000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000C0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000C0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00240027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00230025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0E100F0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x0E0A080D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000000E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x0D0F0C0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x2B2E292B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x12121514 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x10131405 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x262C2D2C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x4747423D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000045 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x0A100C0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x2C2F2C2D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000000E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x0A090B0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x0B0A0A08 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x18191A17 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x16171315 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x0F0D080A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x0B090C07 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04090907 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x050B030B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x07070A0B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07070800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00060907 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x05030000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00080407 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02050408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03010405 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02020102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x06030302 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06050206 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x07030402 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x2624292A +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x26292628 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000A000A +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000014 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000814 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000404B0 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000E0C +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2433_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2433_emc.txt new file mode 100644 index 00000000..59da6201 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2433_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000092 +EMC_RFC_0 = 0x000002AA +EMC_RAS_0 = 0x00000067 +EMC_RP_0 = 0x0000002C +EMC_R2W_0 = 0x0000002C +EMC_W2R_0 = 0x00000028 +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x0000002C +EMC_WR_RCD_0 = 0x0000002C +EMC_RRD_0 = 0x00000013 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000026 +EMC_QRST_0 = 0x00070004 +EMC_QSAFE_0 = 0x00000038 +EMC_RDV_0 = 0x0000003D +EMC_REFRESH_0 = 0x000024D1 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001A +EMC_PDEX2RD_0 = 0x0000001A +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000023 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x0000003A +EMC_TXSR_0 = 0x000002BC +EMC_TCKE_0 = 0x00000015 +EMC_TFAW_0 = 0x00000049 +EMC_TRPAB_0 = 0x00000034 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001C +EMC_TREFBW_0 = 0x00002511 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000048 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02610023 +EMC_MRS_WAIT_CNT_0 = 0x07FF0032 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012283F +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000015 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000D +EMC_EINPUT_DURATION_0 = 0x00000027 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000025 +EMC_TPD_0 = 0x00000013 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000003F +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003D +EMC_RDV_EARLY_0 = 0x0000003B +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186261 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000000 +EMC_TR_RDV_0 = 0x0000003D +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F070A +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000934 +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000494B +EMC_TXSRDLL_0 = 0x000002BC +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000002F +EMC_TR_RDV_MASK_0 = 0x0000003F +EMC_TR_QSAFE_0 = 0x00000038 +EMC_TR_QRST_0 = 0x00070004 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x1000001D +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0D0B +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002F +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000155 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000C0014 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0015000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230030 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0014 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0015000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000C0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000C0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00240028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x10111010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x0E0A080E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x0E100E0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x0B10080A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x14131516 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x10131505 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x414B4D4B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x4848433E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000046 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x0B100D0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0B100B0B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x0C0A0C0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x2C2C2D2A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x1A1A1C18 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x16181416 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x110E090A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x0D0A0E08 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x05080807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04010006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x040B040B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02080006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x07070A0C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x08080800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x01060707 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07060000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00080406 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02050408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03020504 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x03020102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05030504 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04020003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x04020003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06030301 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x27242927 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x27282729 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00060006 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x0000000D +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000814 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x00000000 +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x00000000 +EMC_TRAINING_PATRAM_DQ_0 = 0x00000000 +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040320 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000000 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2466_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2466_emc.txt new file mode 100644 index 00000000..1a5c60f4 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2466_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000094 +EMC_RFC_0 = 0x000002B3 +EMC_RAS_0 = 0x00000068 +EMC_RP_0 = 0x0000002D +EMC_R2W_0 = 0x0000002C +EMC_W2R_0 = 0x00000028 +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x0000002D +EMC_WR_RCD_0 = 0x0000002D +EMC_RRD_0 = 0x00000013 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000026 +EMC_QRST_0 = 0x00070004 +EMC_QSAFE_0 = 0x00000038 +EMC_RDV_0 = 0x0000003D +EMC_REFRESH_0 = 0x00002551 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001A +EMC_PDEX2RD_0 = 0x0000001A +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000023 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x0000003A +EMC_TXSR_0 = 0x000002C5 +EMC_TCKE_0 = 0x00000015 +EMC_TFAW_0 = 0x0000004A +EMC_TRPAB_0 = 0x00000034 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001C +EMC_TREFBW_0 = 0x00002591 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000049 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02690023 +EMC_MRS_WAIT_CNT_0 = 0x07FF0032 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80120215 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000015 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000D +EMC_EINPUT_DURATION_0 = 0x0000001C +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000025 +EMC_TPD_0 = 0x00000013 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430021 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000003F +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003D +EMC_RDV_EARLY_0 = 0x0000003B +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186190 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003D +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000954 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004A46 +EMC_TXSRDLL_0 = 0x000002C5 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000002F +EMC_TR_RDV_MASK_0 = 0x0000003F +EMC_TR_QSAFE_0 = 0x00000038 +EMC_TR_QRST_0 = 0x00070004 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x1000001D +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0D0C +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002B +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000015A +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xCC200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000C0014 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230030 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0014 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000C0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000C0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00240027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00270027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x11131011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x2E2B292D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000002E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x10120F0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x20221E20 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x15141616 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x11151607 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x434C4D4C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x4A49443F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000047 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x0C110E10 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0C110C0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x0E0C0E0E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x0D0D0E0A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x1A1A1C19 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x171A1517 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x12100A0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x0E0C0F08 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04080906 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x050B040B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03090006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x06060709 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07070800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00060A08 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07060100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00060207 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02040308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03020404 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x03020102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x07030403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04020003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x05040104 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06030300 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x23232628 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x28292726 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000A000A +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000014 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000814 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000404D1 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000D0C +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2500_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2500_emc.txt new file mode 100644 index 00000000..1c2e046e --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2500_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000096 +EMC_RFC_0 = 0x000002BC +EMC_RAS_0 = 0x00000069 +EMC_RP_0 = 0x0000002D +EMC_R2W_0 = 0x0000002D +EMC_W2R_0 = 0x00000028 +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x0000002D +EMC_WR_RCD_0 = 0x0000002D +EMC_RRD_0 = 0x00000013 +EMC_REXT_0 = 0x0000001A +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000025 +EMC_QRST_0 = 0x00070003 +EMC_QSAFE_0 = 0x00000039 +EMC_RDV_0 = 0x0000003D +EMC_REFRESH_0 = 0x000025D6 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001A +EMC_PDEX2RD_0 = 0x0000001A +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000023 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x0000003A +EMC_TXSR_0 = 0x000002CF +EMC_TCKE_0 = 0x00000015 +EMC_TFAW_0 = 0x0000004B +EMC_TRPAB_0 = 0x00000035 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001D +EMC_TREFBW_0 = 0x00002616 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000049 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02710023 +EMC_MRS_WAIT_CNT_0 = 0x07FF0032 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012F002 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000016 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000C +EMC_EINPUT_DURATION_0 = 0x00000028 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000026 +EMC_TPD_0 = 0x00000013 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000003F +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003D +EMC_RDV_EARLY_0 = 0x0000003B +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186271 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003D +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000975 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004B49 +EMC_TXSRDLL_0 = 0x000002CF +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000002F +EMC_TR_RDV_MASK_0 = 0x0000003F +EMC_TR_QSAFE_0 = 0x00000039 +EMC_TR_QRST_0 = 0x00070003 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x1000001C +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0B +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002F +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000015E +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00230026 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230030 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x000E0006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000C0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000C0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00240024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x13141313 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x110C0A10 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x11130F10 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x0E130B0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x16151718 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x30323328 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x262C2D2C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x0B0A0500 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x0E121012 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0E130E0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x0F0D0E0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x0F0E0E0B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x1B1C1E1A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x191A1617 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000016 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x14110B0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x0F0C100A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03080806 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04080408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x01060004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0806090B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07070800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x01060A09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07050100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00060207 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02040208 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04010405 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x03020102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x07030403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x04030003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x07040403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x2624232A +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x26292626 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000A000A +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000015 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000814 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000404E2 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0B +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2533_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2533_emc.txt new file mode 100644 index 00000000..1e0eb380 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2533_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000098 +EMC_RFC_0 = 0x000002C6 +EMC_RAS_0 = 0x0000006B +EMC_RP_0 = 0x0000002E +EMC_R2W_0 = 0x0000002D +EMC_W2R_0 = 0x00000029 +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x0000002E +EMC_WR_RCD_0 = 0x0000002E +EMC_RRD_0 = 0x00000013 +EMC_REXT_0 = 0x0000001C +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000025 +EMC_QRST_0 = 0x00080001 +EMC_QSAFE_0 = 0x0000003C +EMC_RDV_0 = 0x0000003D +EMC_REFRESH_0 = 0x00002657 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001A +EMC_PDEX2RD_0 = 0x0000001A +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000024 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x0000003A +EMC_TXSR_0 = 0x000002D9 +EMC_TCKE_0 = 0x00000015 +EMC_TFAW_0 = 0x0000004C +EMC_TRPAB_0 = 0x00000036 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001D +EMC_TREFBW_0 = 0x00002697 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000004A +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x027A0024 +EMC_MRS_WAIT_CNT_0 = 0x07FF0032 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80040101 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000016 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000B +EMC_EINPUT_DURATION_0 = 0x00000029 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000026 +EMC_TPD_0 = 0x00000013 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1E180000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000003F +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003D +EMC_RDV_EARLY_0 = 0x0000003B +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x0118627A +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003D +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000995 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004C44 +EMC_TXSRDLL_0 = 0x000002D9 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000002F +EMC_TR_RDV_MASK_0 = 0x0000003F +EMC_TR_QSAFE_0 = 0x0000003C +EMC_TR_QRST_0 = 0x00080001 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x1000001B +EMC_OBDLY_0 = 0x10000000 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0D0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002F +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000163 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A00A010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00210029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000C0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x00060000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x001E0021 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x14151414 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x120E0B11 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x12141111 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x0F140C0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x1817191A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x15181909 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000016 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x040F100E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x2B2A2723 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x0F141113 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0F150F11 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x100F1010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x100F100C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x1E1E1F1D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x1A1D181A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000018 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x14120D0E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x100E120B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04090908 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04010006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04080408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08080B0C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x06070700 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00040505 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07040000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00060308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03050308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x05040706 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x05040404 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x06020503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x07060207 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x08030503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x25242428 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x25292825 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000A000A +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000015 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000815 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000404F3 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000D0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2566_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2566_emc.txt new file mode 100644 index 00000000..9449638a --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2566_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x0000009A +EMC_RFC_0 = 0x000002CF +EMC_RAS_0 = 0x0000006C +EMC_RP_0 = 0x0000002F +EMC_R2W_0 = 0x0000002D +EMC_W2R_0 = 0x00000029 +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x0000002F +EMC_WR_RCD_0 = 0x0000002F +EMC_RRD_0 = 0x00000014 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000026 +EMC_QRST_0 = 0x00080002 +EMC_QSAFE_0 = 0x0000003C +EMC_RDV_0 = 0x0000003E +EMC_REFRESH_0 = 0x000026D7 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001B +EMC_PDEX2RD_0 = 0x0000001B +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000024 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x0000003A +EMC_TXSR_0 = 0x000002E2 +EMC_TCKE_0 = 0x00000016 +EMC_TFAW_0 = 0x0000004D +EMC_TRPAB_0 = 0x00000036 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001D +EMC_TREFBW_0 = 0x00002717 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000004C +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02820024 +EMC_MRS_WAIT_CNT_0 = 0x07FF0032 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012D4E6 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000016 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000C +EMC_EINPUT_DURATION_0 = 0x00000029 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000027 +EMC_TPD_0 = 0x00000014 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000040 +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003E +EMC_RDV_EARLY_0 = 0x0000003C +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186282 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003E +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x000009B5 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004D3F +EMC_TXSRDLL_0 = 0x000002E2 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000030 +EMC_TR_RDV_MASK_0 = 0x00000040 +EMC_TR_QSAFE_0 = 0x0000003C +EMC_TR_QRST_0 = 0x00080002 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x1000001C +EMC_OBDLY_0 = 0x10000000 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000030 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000168 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230031 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000D0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000D0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00270028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x15151416 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x130F0C13 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x13161312 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x10160D0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x19191B1B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x16191A0A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000017 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x0610110F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x0D0C0702 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x10151214 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x10161011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x110F1113 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1110110E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x1D1F211C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x1B1D181A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000018 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x15140E0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x110F120B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x05090909 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x05010006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x050A050A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03070005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x07070A0C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07080900 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00060A09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x08060100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03050308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04010405 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02020102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x06030403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x08060307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x08050503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x27232629 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x28262425 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000A000A +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000015 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000815 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040320 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2600_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2600_emc.txt new file mode 100644 index 00000000..b3b813bf --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2600_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x0000009C +EMC_RFC_0 = 0x000002D8 +EMC_RAS_0 = 0x0000006E +EMC_RP_0 = 0x0000002F +EMC_R2W_0 = 0x0000002D +EMC_W2R_0 = 0x00000029 +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x0000002F +EMC_WR_RCD_0 = 0x0000002F +EMC_RRD_0 = 0x00000014 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000026 +EMC_QRST_0 = 0x00080002 +EMC_QSAFE_0 = 0x0000003C +EMC_RDV_0 = 0x0000003E +EMC_REFRESH_0 = 0x0000275C +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001B +EMC_PDEX2RD_0 = 0x0000001B +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000025 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x0000003A +EMC_TXSR_0 = 0x000002EC +EMC_TCKE_0 = 0x00000016 +EMC_TFAW_0 = 0x0000004E +EMC_TRPAB_0 = 0x00000037 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001E +EMC_TREFBW_0 = 0x0000279C +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000004C +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x028A0025 +EMC_MRS_WAIT_CNT_0 = 0x07FF0033 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80040101 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000017 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000C +EMC_EINPUT_DURATION_0 = 0x00000029 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000027 +EMC_TPD_0 = 0x00000014 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1E190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000040 +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003E +EMC_RDV_EARLY_0 = 0x0000003C +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x0118628A +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003E +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x000009D7 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004E41 +EMC_TXSRDLL_0 = 0x000002EC +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000030 +EMC_TR_RDV_MASK_0 = 0x00000040 +EMC_TR_QSAFE_0 = 0x0000003C +EMC_TR_QRST_0 = 0x00080002 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030E +EMC_IBDLY_0 = 0x1000001C +EMC_OBDLY_0 = 0x10000000 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0B +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000030 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000016C +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000012 +EMC_CMD_BRLSHFT_3_0 = 0x00000012 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x88200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0017000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230031 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0017000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000D0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000D0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00270028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x16161515 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x140F0E14 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x15161414 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x11170E11 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x1B1A1C1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x171A1C0B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000018 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x07111311 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x0F0E0903 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000028 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x12181416 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x12181213 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000016 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x12111213 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x2C2C2D2A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x37373735 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x34353234 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000001A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x17160F11 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x2D2B2E29 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000002B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x05090909 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x05010007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04090409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02060004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08070A0C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x08080900 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00060A09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x08060000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00080408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03050408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04020506 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x03020203 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x06020302 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06050205 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06040301 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x26232528 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x28282627 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000A000A +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00170017 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000015 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000815 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040514 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0B +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2633_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2633_emc.txt new file mode 100644 index 00000000..d2f1221a --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2633_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x0000009E +EMC_RFC_0 = 0x000002E2 +EMC_RAS_0 = 0x0000006F +EMC_RP_0 = 0x00000030 +EMC_R2W_0 = 0x0000002D +EMC_W2R_0 = 0x0000002A +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x00000030 +EMC_WR_RCD_0 = 0x00000030 +EMC_RRD_0 = 0x00000014 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000026 +EMC_QRST_0 = 0x00080001 +EMC_QSAFE_0 = 0x0000003D +EMC_RDV_0 = 0x0000003E +EMC_REFRESH_0 = 0x000027DD +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001B +EMC_PDEX2RD_0 = 0x0000001B +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000025 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x0000003A +EMC_TXSR_0 = 0x000002F5 +EMC_TCKE_0 = 0x00000016 +EMC_TFAW_0 = 0x0000004F +EMC_TRPAB_0 = 0x00000038 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001E +EMC_TREFBW_0 = 0x0000281D +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000004D +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02930025 +EMC_MRS_WAIT_CNT_0 = 0x07FF0033 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012B1C2 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000017 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000B +EMC_EINPUT_DURATION_0 = 0x0000002A +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000028 +EMC_TPD_0 = 0x00000014 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000040 +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003E +EMC_RDV_EARLY_0 = 0x0000003C +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186293 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003E +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x000009F7 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004F3C +EMC_TXSRDLL_0 = 0x000002F5 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000030 +EMC_TR_RDV_MASK_0 = 0x00000040 +EMC_TR_QSAFE_0 = 0x0000003D +EMC_TR_QRST_0 = 0x00080001 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030E +EMC_IBDLY_0 = 0x1000001C +EMC_OBDLY_0 = 0x10000000 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0D09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000030 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000171 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000D0016 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0017000B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230031 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000D0016 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0017000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000D0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000D0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x0028002A +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00240026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00240027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x18181818 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x16120F15 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000017 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x16181615 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x12180F12 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x1C1C1D1D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x191C1D0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000001A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x08121311 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x0F0E0A04 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x12171417 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x13181314 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000022 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x13121315 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1312130F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x2021231F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x1E201A1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000001B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x17161011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x1411150E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x040A0A09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04010007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x05050305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03070005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x06060709 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x06070700 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00070E0A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x090A0300 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00080308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03060309 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x05040807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x05040404 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x06020403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x08070408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x03010101 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x2A222428 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x23272726 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x00080008 +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x000E000E +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000016 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x0000080D +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040525 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000D09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2666_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2666_emc.txt new file mode 100644 index 00000000..e7944074 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/emc/2666_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000A0 +EMC_RFC_0 = 0x000002EB +EMC_RAS_0 = 0x00000070 +EMC_RP_0 = 0x00000030 +EMC_R2W_0 = 0x0000002D +EMC_W2R_0 = 0x0000002A +EMC_R2P_0 = 0x0000000C +EMC_W2P_0 = 0x0000002D +EMC_RD_RCD_0 = 0x00000030 +EMC_WR_RCD_0 = 0x00000030 +EMC_RRD_0 = 0x00000014 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x00000026 +EMC_QRST_0 = 0x00080001 +EMC_QSAFE_0 = 0x0000003D +EMC_RDV_0 = 0x0000003E +EMC_REFRESH_0 = 0x0000285D +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001B +EMC_PDEX2RD_0 = 0x0000001B +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000026 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x0000003A +EMC_TXSR_0 = 0x000002FF +EMC_TCKE_0 = 0x00000016 +EMC_TFAW_0 = 0x00000050 +EMC_TRPAB_0 = 0x00000038 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001E +EMC_TREFBW_0 = 0x0000289D +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000004D +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x029B0026 +EMC_MRS_WAIT_CNT_0 = 0x07FF0033 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012A5B6 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000017 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802002D +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000B +EMC_EINPUT_DURATION_0 = 0x0000002A +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000028 +EMC_TPD_0 = 0x00000014 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000040 +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x0000003E +EMC_RDV_EARLY_0 = 0x0000003C +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x0118629B +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003E +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000A17 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005037 +EMC_TXSRDLL_0 = 0x000002FF +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000030 +EMC_TR_RDV_MASK_0 = 0x00000040 +EMC_TR_QSAFE_0 = 0x0000003D +EMC_TR_QRST_0 = 0x00080001 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030E +EMC_IBDLY_0 = 0x1000001C +EMC_OBDLY_0 = 0x10000000 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0D0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000030 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000176 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x88200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000D0016 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0017000B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230032 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000D0016 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0017000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000D0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000D0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00280029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00240027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00210027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x19191818 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x17121016 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000017 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x18191616 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x2B2E292A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x33323433 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x191D1F0E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000001B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x09141513 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x11100B05 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000000E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x131A1618 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x14191516 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x15141516 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x14141511 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x37373735 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x20221C1E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000001C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x19171113 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x1412160F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04090909 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x05000007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x050B050B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x04080005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08080A0E +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0A0A0A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x01090B09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x09070200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00090508 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0306050A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x05050807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x06050504 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x08030403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04010001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06050105 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x05040301 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x24242628 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x25262827 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00170017 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000016 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x0000080D +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040535 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000D0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/1600_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/1600_mc.txt new file mode 100644 index 00000000..115a3218 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/1600_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFC9B +MC_SMMU_PTC_FLUSH_0 = 0x77DEB251 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0000000C +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000006 +MC_EMEM_ARB_TIMING_RP_0 = 0x00000007 +MC_EMEM_ARB_TIMING_RC_0 = 0x00000018 +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000000F +MC_EMEM_ARB_TIMING_FAW_0 = 0x0000000F +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000003 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000D +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000C +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000A +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x000D080C +MC_EMEM_ARB_MISC0_0 = 0x726C2419 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C511020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80100080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630B0 +MC_ERR_SEC_ADR_0 = 0x0A930850 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000037 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000000 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x00000228 +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00800038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00800005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00800014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x0080001D +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00800095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00800041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0080003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00800019 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000080 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00800090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000080 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080016 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00800019 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00800005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00800018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/1866_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/1866_mc.txt new file mode 100644 index 00000000..a7abda3c --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/1866_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x4A005160 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFBDB +MC_SMMU_PTC_FLUSH_0 = 0x75C5BF41 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0000000E +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000007 +MC_EMEM_ARB_TIMING_RP_0 = 0x00000008 +MC_EMEM_ARB_TIMING_RC_0 = 0x0000001C +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000012 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000012 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000C +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000A +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x000E090E +MC_EMEM_ARB_MISC0_0 = 0x726E2A1D +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x00000041 +MC_ERR_VPR_ADR_0 = 0x0C111020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80020080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000010E0 +MC_ERR_SEC_ADR_0 = 0x02013000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000041 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x000000F2 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x00000335 +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001B +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x00001501 +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x006D0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x006D0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x006D0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x006D0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x006D006D +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x006D0019 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x006D0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x006D0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x006D0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x006D003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x006D0016 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000006D +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x006D0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x006D0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000006D +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080013 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x006D0016 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x006D0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x006D0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2133_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2133_mc.txt new file mode 100644 index 00000000..fdb09f8e --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2133_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD0B +MC_SMMU_PTC_FLUSH_0 = 0x77E72431 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000010 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80050080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000008 +MC_EMEM_ARB_TIMING_RP_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RC_0 = 0x00000020 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000015 +MC_EMEM_ARB_TIMING_FAW_0 = 0x0000000F +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000003 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000C +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x000F0A10 +MC_EMEM_ARB_MISC0_0 = 0x72703021 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80020080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000230F0 +MC_ERR_SEC_ADR_0 = 0x0A130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000004A +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00600004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00600038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00600005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00600014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00600060 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00600016 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00600095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00600041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00600080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0060003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00600013 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000060 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00600090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00600004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000060 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080011 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00600013 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00600005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00600018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2166_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2166_mc.txt new file mode 100644 index 00000000..14b30255 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2166_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD8B +MC_SMMU_PTC_FLUSH_0 = 0x77E3E631 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000010 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000008 +MC_EMEM_ARB_TIMING_RP_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RC_0 = 0x00000020 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000015 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000010 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000C +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x000F0A10 +MC_EMEM_ARB_MISC0_0 = 0x72713121 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630B0 +MC_ERR_SEC_ADR_0 = 0x0A130810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000004B +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x005E0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x005E0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x005E0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x005E0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x005E005E +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x005E0015 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x005E0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x005E0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x005E0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x005E003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x005E0013 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000005E +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x005E0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x005E0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000005E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080010 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x005E0013 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x005E0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x005E0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2200_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2200_mc.txt new file mode 100644 index 00000000..0f23b5f2 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2200_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCDB +MC_SMMU_PTC_FLUSH_0 = 0x77D49341 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x08000010 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000008 +MC_EMEM_ARB_TIMING_RP_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RC_0 = 0x00000021 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000016 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000010 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000C +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00100B10 +MC_EMEM_ARB_MISC0_0 = 0x72713222 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C1D1000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80020080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02910800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000004C +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x005D0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x005D0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x005D0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x005D0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x005D005D +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x005D0015 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x005D0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x005D0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x005D0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x005D003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x005D0012 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000005D +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x005D0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x005D0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000005D +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080010 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x005D0012 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x005D0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x005D0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2233_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2233_mc.txt new file mode 100644 index 00000000..c3c260db --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2233_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x01011200 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD5B +MC_SMMU_PTC_FLUSH_0 = 0x77E3F551 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000010 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80040080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000021 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000016 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000010 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000C +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00100B10 +MC_EMEM_ARB_MISC0_0 = 0x72713322 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02132800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000004E +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x005B0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x005B0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x005B0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x005B0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x005B005B +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x005B0015 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x005B0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x005B0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x005B0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x005B003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x005B0012 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000005B +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x005B0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x005B0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000005B +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080010 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x005B0012 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x005B0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x005B0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2266_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2266_mc.txt new file mode 100644 index 00000000..84106132 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2266_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFDBB +MC_SMMU_PTC_FLUSH_0 = 0x77E6F6D1 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000011 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000022 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000016 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000010 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000C +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00100B11 +MC_EMEM_ARB_MISC0_0 = 0x72713323 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C1D1020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000004F +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x005A0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x005A0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x005A0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x005A0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x005A005A +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x005A0014 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x005A0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x005A0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x005A0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x005A003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x005A0012 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000005A +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x005A0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x005A0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000005A +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080010 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x005A0012 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x005A0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x005A0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2300_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2300_mc.txt new file mode 100644 index 00000000..c5c48bf8 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2300_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x01211200 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFDDB +MC_SMMU_PTC_FLUSH_0 = 0x77E4C761 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000011 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80010080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000022 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000017 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000011 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000C +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00100B11 +MC_EMEM_ARB_MISC0_0 = 0x72723423 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C111020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80040080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630B0 +MC_ERR_SEC_ADR_0 = 0x02132800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000050 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00590004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00590038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00590005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00590014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00590059 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00590014 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00590095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00590041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00590080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0059003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00590012 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000059 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00590090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00590004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000059 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000F +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00590012 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00590005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00590018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2333_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2333_mc.txt new file mode 100644 index 00000000..a512eb64 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2333_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x00000000 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFC1B +MC_SMMU_PTC_FLUSH_0 = 0x77E44061 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x08000011 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000022 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000017 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000011 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000C +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00100B11 +MC_EMEM_ARB_MISC0_0 = 0x72723523 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000010E0 +MC_ERR_SEC_ADR_0 = 0x02000000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000051 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00570004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00570038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00570005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00570014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00570057 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00570014 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00570095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00570041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00570080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0057003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00800019 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000057 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00570090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00570004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000057 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000F +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00570011 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00570005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00570018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2366_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2366_mc.txt new file mode 100644 index 00000000..e0f1a8ba --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2366_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x01211200 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCEB +MC_SMMU_PTC_FLUSH_0 = 0x77E38391 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000011 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000023 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000017 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000011 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000C +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00100B11 +MC_EMEM_ARB_MISC0_0 = 0x72723624 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C151000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x00063070 +MC_ERR_SEC_ADR_0 = 0x02130000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000052 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00560004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00560038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00560005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00560014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00560056 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00560013 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00560095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00560041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00560080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0056003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00560011 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000056 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00560090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00560004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000056 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000F +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00560011 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00560005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00560018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2400_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2400_mc.txt new file mode 100644 index 00000000..5079a5e8 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2400_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD4B +MC_SMMU_PTC_FLUSH_0 = 0x77CDF531 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000012 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000024 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000018 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000011 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000C +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00110C12 +MC_EMEM_ARB_MISC0_0 = 0x72723625 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C1D1020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x0A110000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000053 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00550004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00550038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00550005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00550014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00550055 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00550013 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00550095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00550041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00550080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0055003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00550011 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000055 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00550090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00550004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000055 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000F +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00550011 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00550005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00550018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2433_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2433_mc.txt new file mode 100644 index 00000000..a80c488e --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2433_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x01010200 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000007F +MC_SMMU_PTB_DATA_0 = 0x00000000 +MC_SMMU_TLB_FLUSH_0 = 0x000FFDFB +MC_SMMU_PTC_FLUSH_0 = 0x7A41F7E1 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000012 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000024 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000018 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000012 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000C +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00110C12 +MC_EMEM_ARB_MISC0_0 = 0x72733725 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000C0800 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8800 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C1910A0 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000055 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000120 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000120 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x00000363 +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x00000000 +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x0000000E +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00540004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00540038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00540005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00540014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00540054 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00540013 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00540095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00540041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00540080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0054003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00540011 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000054 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00540090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00540004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000054 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000F +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00540011 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00540005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00540018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2466_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2466_mc.txt new file mode 100644 index 00000000..a2771c5f --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2466_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCFB +MC_SMMU_PTC_FLUSH_0 = 0x77E273C1 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x08000012 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80040080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000025 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000018 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000012 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000C +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00110C12 +MC_EMEM_ARB_MISC0_0 = 0x72733826 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000056 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00530004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00530038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00530005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00530014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00530053 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00530013 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00530095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00530041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00530080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0053003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00530010 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000053 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00530090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00530004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000053 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000E +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00530010 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00530005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00530018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2500_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2500_mc.txt new file mode 100644 index 00000000..e1f6a537 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2500_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFC6B +MC_SMMU_PTC_FLUSH_0 = 0x77D351A1 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000012 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x800C0080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000025 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000019 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000012 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00110C12 +MC_EMEM_ARB_MISC0_0 = 0x72733926 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C1D1020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000230F0 +MC_ERR_SEC_ADR_0 = 0x02910800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000057 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00510004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00510038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00510005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00510014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00510051 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00510012 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00510095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00510041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00510080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0051003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00510010 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000051 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00510090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00510004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000051 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000E +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00510010 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00510005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00510018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2533_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2533_mc.txt new file mode 100644 index 00000000..19a51d9c --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2533_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCDB +MC_SMMU_PTC_FLUSH_0 = 0x77DCA341 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000013 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000026 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000019 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000012 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00110C13 +MC_EMEM_ARB_MISC0_0 = 0x72733927 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C1D1000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x00023070 +MC_ERR_SEC_ADR_0 = 0x02130000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000058 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00500004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00500038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00500005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00500014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00500050 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00500012 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00500095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00500041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00500080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0050003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00500010 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000050 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00500090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00500004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000050 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000E +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00500010 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00500005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00500018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2566_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2566_mc.txt new file mode 100644 index 00000000..18509a13 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2566_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCDB +MC_SMMU_PTC_FLUSH_0 = 0x77E72341 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000013 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000026 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000019 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000013 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00110C13 +MC_EMEM_ARB_MISC0_0 = 0x72743A27 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C111000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02110000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000059 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x004F0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x004F0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x004F0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x004F0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x004F004F +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x004F0012 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x004F0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x004F0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x004F0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x004F003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x004F0010 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000004F +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x004F0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x004F0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000004F +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000E +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x004F0010 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x004F0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x004F0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2600_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2600_mc.txt new file mode 100644 index 00000000..addb44fd --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2600_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD5B +MC_SMMU_PTC_FLUSH_0 = 0x77E74541 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x08000013 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000027 +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001A +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000013 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00110C13 +MC_EMEM_ARB_MISC0_0 = 0x72743B28 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x00063070 +MC_ERR_SEC_ADR_0 = 0x02130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000005A +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x004E0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x004E0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x004E0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x004E0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x004E004E +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x004E0012 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x004E0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x004E0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x004E0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x004E003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x004E0010 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000004E +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x004E0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x004E0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000004E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000E +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x004E0010 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x004E0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x004E0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2633_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2633_mc.txt new file mode 100644 index 00000000..2a2bcdb1 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2633_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0xF4028180 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD3B +MC_SMMU_PTC_FLUSH_0 = 0x77E8C4C1 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000013 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80010080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000027 +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001A +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000013 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00120D13 +MC_EMEM_ARB_MISC0_0 = 0x72743C28 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x00000040 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80070080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630B0 +MC_ERR_SEC_ADR_0 = 0x0A930850 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000005C +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000363 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000D +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x004D0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x004D0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x004D0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x004D0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x004D004D +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x004D0011 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x004D0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x004D0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x004D0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x004D003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x004D000F +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000004D +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x004D0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x004D0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000004D +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000D +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x004D000F +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x004D0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x004D0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2666_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2666_mc.txt new file mode 100644 index 00000000..c994b6f4 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1600/mc/2666_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFBDB +MC_SMMU_PTC_FLUSH_0 = 0x4225CF41 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000014 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000027 +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001A +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000013 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000E +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00120D13 +MC_EMEM_ARB_MISC0_0 = 0x72743C28 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000005D +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000363 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000D +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x004C0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x004C0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x004C0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x004C0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x004C004C +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x004C0011 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x004C0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x004C0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x004C0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x004C003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x004C000F +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000004C +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x004C0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x004C0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000004C +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000D +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x004C000F +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x004C0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x004C0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/1866_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/1866_emc.txt new file mode 100644 index 00000000..e9a49297 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/1866_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000070 +EMC_RFC_0 = 0x0000020B +EMC_RAS_0 = 0x0000004F +EMC_RP_0 = 0x00000022 +EMC_R2W_0 = 0x0000002E +EMC_W2R_0 = 0x00000025 +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000022 +EMC_WR_RCD_0 = 0x00000022 +EMC_RRD_0 = 0x00000013 +EMC_REXT_0 = 0x0000001A +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x00000028 +EMC_QRST_0 = 0x0007000C +EMC_QSAFE_0 = 0x00000038 +EMC_RDV_0 = 0x0000003E +EMC_REFRESH_0 = 0x00001C2D +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000013 +EMC_PDEX2RD_0 = 0x00000013 +EMC_PCHG2PDEN_0 = 0x00000004 +EMC_ACT2PDEN_0 = 0x0000001B +EMC_AR2PDEN_0 = 0x00000004 +EMC_RW2PDEN_0 = 0x0000003F +EMC_TXSR_0 = 0x00000219 +EMC_TCKE_0 = 0x00000010 +EMC_TFAW_0 = 0x0000004B +EMC_TRPAB_0 = 0x00000028 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x00000017 +EMC_TREFBW_0 = 0x00001C6D +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000037 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x01D3001B +EMC_MRS_WAIT_CNT_0 = 0x074A0034 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80040101 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000010 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000015 +EMC_EINPUT_DURATION_0 = 0x00000020 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000001C +EMC_TPD_0 = 0x0000000E +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000040 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x0000003E +EMC_RDV_EARLY_0 = 0x0000003C +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x0039074A +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011861D3 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003E +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080A +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x0000070B +EMC_DYN_SELF_REF_CONTROL_0 = 0x80003873 +EMC_TXSRDLL_0 = 0x00000219 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000030 +EMC_TR_RDV_MASK_0 = 0x00000040 +EMC_TR_QSAFE_0 = 0x00000038 +EMC_TR_QRST_0 = 0x0007000C +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030A +EMC_IBDLY_0 = 0x1000001F +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0D0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000030 +EMC_QUSE_WIDTH_0 = 0x00000009 +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000106 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x0009000F +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00100007 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x00210028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x00200028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00230027 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x0009000F +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00100007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x00020008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x00090000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x00020007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x00090000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00240025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x001F0023 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00200023 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x31323332 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x312E2C30 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000030 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x2F302E2E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x2D312A2C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000002B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x37363837 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x3436372B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000035 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x282F302F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x2D2D2925 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000002A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x20242123 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x2F333030 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000002E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x2F2E2E2F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x2E2E2E2C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000002E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x3A3A3B39 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x38393638 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000035 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x31312D2E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x302E312C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000002D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04060506 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04010005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x05070307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0707090B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07080800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050706 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x05040100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00030205 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02040106 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03000203 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x00030002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05040503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x04030103 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x04030201 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x25202726 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x29272322 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x000F000F +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00070007 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00100010 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x0000000F +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x0000080F +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000403A5 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000D0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2133_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2133_emc.txt new file mode 100644 index 00000000..79bf8c72 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2133_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000080 +EMC_RFC_0 = 0x00000256 +EMC_RAS_0 = 0x0000005A +EMC_RP_0 = 0x00000027 +EMC_R2W_0 = 0x0000002F +EMC_W2R_0 = 0x00000027 +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000027 +EMC_WR_RCD_0 = 0x00000027 +EMC_RRD_0 = 0x00000010 +EMC_REXT_0 = 0x0000001A +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x00000028 +EMC_QRST_0 = 0x00070009 +EMC_QSAFE_0 = 0x00000039 +EMC_RDV_0 = 0x0000003F +EMC_REFRESH_0 = 0x0000203F +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000016 +EMC_PDEX2RD_0 = 0x00000016 +EMC_PCHG2PDEN_0 = 0x00000004 +EMC_ACT2PDEN_0 = 0x0000001E +EMC_AR2PDEN_0 = 0x00000004 +EMC_RW2PDEN_0 = 0x0000003F +EMC_TXSR_0 = 0x00000266 +EMC_TCKE_0 = 0x00000012 +EMC_TFAW_0 = 0x00000040 +EMC_TRPAB_0 = 0x0000002D +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001A +EMC_TREFBW_0 = 0x0000207F +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000003F +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x0216001E +EMC_MRS_WAIT_CNT_0 = 0x07FF0035 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012273E +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000013 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000012 +EMC_EINPUT_DURATION_0 = 0x00000024 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000020 +EMC_TPD_0 = 0x00000010 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000041 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x0000003F +EMC_RDV_EARLY_0 = 0x0000003D +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186216 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x0000003F +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x0000080F +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004062 +EMC_TXSRDLL_0 = 0x00000266 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000031 +EMC_TR_RDV_MASK_0 = 0x00000041 +EMC_TR_QSAFE_0 = 0x00000039 +EMC_TR_QRST_0 = 0x00070009 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030B +EMC_IBDLY_0 = 0x1000001F +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000031 +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000012B +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A002018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x80200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x00210029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000A0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000A0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00240025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00250025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210023 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x3E3F3F40 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x3D39383D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000003D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x3A3D3A39 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x393D3538 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000036 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x43424443 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x3F424336 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000040 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x323A3B3A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x3937332F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000036 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x393D3B3E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x3A3E3A3B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000003C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x3A39393A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x3A393936 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000039 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x08080907 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x05070205 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x3D3D3839 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x3B3A3C37 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000039 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03070706 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x03000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x05050305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03060003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0707090A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07080900 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06040000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070306 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03050407 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03030505 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x04030302 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05040402 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x05040104 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06030301 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x26262629 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x29292A27 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00120012 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000012 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000812 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004042B +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2166_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2166_emc.txt new file mode 100644 index 00000000..7492758d --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2166_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000082 +EMC_RFC_0 = 0x0000025F +EMC_RAS_0 = 0x0000005B +EMC_RP_0 = 0x00000027 +EMC_R2W_0 = 0x0000002F +EMC_W2R_0 = 0x00000027 +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000027 +EMC_WR_RCD_0 = 0x00000027 +EMC_RRD_0 = 0x00000011 +EMC_REXT_0 = 0x00000019 +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x00000029 +EMC_QRST_0 = 0x0007000A +EMC_QSAFE_0 = 0x0000003A +EMC_RDV_0 = 0x00000040 +EMC_REFRESH_0 = 0x000020BF +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000017 +EMC_PDEX2RD_0 = 0x00000017 +EMC_PCHG2PDEN_0 = 0x00000004 +EMC_ACT2PDEN_0 = 0x0000001F +EMC_AR2PDEN_0 = 0x00000004 +EMC_RW2PDEN_0 = 0x0000003F +EMC_TXSR_0 = 0x0000026F +EMC_TCKE_0 = 0x00000013 +EMC_TFAW_0 = 0x00000041 +EMC_TRPAB_0 = 0x0000002E +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001A +EMC_TREFBW_0 = 0x000020FF +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000040 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x021E001F +EMC_MRS_WAIT_CNT_0 = 0x07FF0035 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012AFCD +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000013 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000013 +EMC_EINPUT_DURATION_0 = 0x00000024 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000021 +EMC_TPD_0 = 0x00000011 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000042 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000040 +EMC_RDV_EARLY_0 = 0x0000003E +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x0118621E +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000040 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080A +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x0000082F +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000415D +EMC_TXSRDLL_0 = 0x0000026F +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000032 +EMC_TR_RDV_MASK_0 = 0x00000042 +EMC_TR_QSAFE_0 = 0x0000003A +EMC_TR_QRST_0 = 0x0007000A +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030B +EMC_IBDLY_0 = 0x10000020 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000032 +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000130 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A002010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x00210029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000B0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000B0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00250025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00200024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x40414141 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x3F3B393E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000003F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x3C3E3C3B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x3B3F373A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000038 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x44434444 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x41434437 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000042 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x333B3C3B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x3A393431 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000037 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x3A3F3D3E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x3C3F3C3C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000003D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x3B3A3B3C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x3B3B3B39 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000003A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x090A0B08 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x07080406 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x3E3F393C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x3D3B3E38 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000003A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03060706 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x02000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04080408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02060004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x07080A0B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07080800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06040000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070407 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03060508 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02000102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05040502 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x02020003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06040105 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06030301 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x2823282A +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x29292628 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00120012 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000012 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000812 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004043B +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2200_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2200_emc.txt new file mode 100644 index 00000000..1cae81aa --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2200_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000084 +EMC_RFC_0 = 0x00000268 +EMC_RAS_0 = 0x0000005D +EMC_RP_0 = 0x00000028 +EMC_R2W_0 = 0x0000002F +EMC_W2R_0 = 0x00000027 +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000028 +EMC_WR_RCD_0 = 0x00000028 +EMC_RRD_0 = 0x00000011 +EMC_REXT_0 = 0x00000019 +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x00000029 +EMC_QRST_0 = 0x0007000A +EMC_QSAFE_0 = 0x0000003A +EMC_RDV_0 = 0x00000040 +EMC_REFRESH_0 = 0x00002144 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000017 +EMC_PDEX2RD_0 = 0x00000017 +EMC_PCHG2PDEN_0 = 0x00000004 +EMC_ACT2PDEN_0 = 0x0000001F +EMC_AR2PDEN_0 = 0x00000004 +EMC_RW2PDEN_0 = 0x0000003F +EMC_TXSR_0 = 0x00000279 +EMC_TCKE_0 = 0x00000013 +EMC_TFAW_0 = 0x00000042 +EMC_TRPAB_0 = 0x0000002F +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001A +EMC_TREFBW_0 = 0x00002184 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000041 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x0226001F +EMC_MRS_WAIT_CNT_0 = 0x07FF0035 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012293F +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000013 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000013 +EMC_EINPUT_DURATION_0 = 0x00000024 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000021 +EMC_TPD_0 = 0x00000011 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1E190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000042 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000040 +EMC_RDV_EARLY_0 = 0x0000003E +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186226 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000040 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000851 +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000425F +EMC_TXSRDLL_0 = 0x00000279 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000032 +EMC_TR_RDV_MASK_0 = 0x00000042 +EMC_TR_QSAFE_0 = 0x0000003A +EMC_TR_QRST_0 = 0x0007000A +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x10000020 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002B +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000134 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A01A010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00010014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x00210027 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000B0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000B0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x001E0022 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x41414242 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x403C3A3F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000040 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x3E403D3D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x3D42393B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000003A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x46444747 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x42454638 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000043 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x353D3E3D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x3B3A3532 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000038 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x3C413F41 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x3E423E3E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000002E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x3C3B3C3D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x3C3C3C39 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000003B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x0B0C0D0A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x080A0608 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x40413B3D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x2D2B2E29 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000003C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04070707 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x03010005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04080408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x01060004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0707090B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07080800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00060908 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07050000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03060408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02010305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02030102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05040502 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x05040005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06030301 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x27252729 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x29272827 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00120012 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000012 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000812 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004044C +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2233_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2233_emc.txt new file mode 100644 index 00000000..7ce76178 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2233_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000086 +EMC_RFC_0 = 0x00000272 +EMC_RAS_0 = 0x0000005E +EMC_RP_0 = 0x00000029 +EMC_R2W_0 = 0x0000002F +EMC_W2R_0 = 0x00000028 +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000029 +EMC_WR_RCD_0 = 0x00000029 +EMC_RRD_0 = 0x00000011 +EMC_REXT_0 = 0x00000019 +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x00000029 +EMC_QRST_0 = 0x00070009 +EMC_QSAFE_0 = 0x0000003A +EMC_RDV_0 = 0x00000040 +EMC_REFRESH_0 = 0x000021C5 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000017 +EMC_PDEX2RD_0 = 0x00000017 +EMC_PCHG2PDEN_0 = 0x00000004 +EMC_ACT2PDEN_0 = 0x00000020 +EMC_AR2PDEN_0 = 0x00000004 +EMC_RW2PDEN_0 = 0x00000040 +EMC_TXSR_0 = 0x00000282 +EMC_TCKE_0 = 0x00000013 +EMC_TFAW_0 = 0x00000043 +EMC_TRPAB_0 = 0x0000002F +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001A +EMC_TREFBW_0 = 0x00002205 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000042 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x022F0020 +EMC_MRS_WAIT_CNT_0 = 0x07FF0035 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012839F +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000013 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000012 +EMC_EINPUT_DURATION_0 = 0x00000025 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000022 +EMC_TPD_0 = 0x00000011 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D180000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000042 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000040 +EMC_RDV_EARLY_0 = 0x0000003E +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x0118622F +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000040 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000871 +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000435A +EMC_TXSRDLL_0 = 0x00000282 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000032 +EMC_TR_RDV_MASK_0 = 0x00000042 +EMC_TR_QSAFE_0 = 0x0000003A +EMC_TR_QRST_0 = 0x00070009 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x10000020 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000032 +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000139 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A01A010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002F +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000B0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000B0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00200023 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x42424344 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x413D3B40 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000041 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x3F423F3E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x3E433A3D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000003B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x48474949 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x4547483B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000046 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x353E403E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x3D3B3633 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000039 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x3E424042 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x3F433F3F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000041 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x3E3C3D3F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x3E3E3E3B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000003D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x0D0E0E0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x0A0B0809 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x42433D3E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x2C2B2E29 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000003D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04080806 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x03000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04090408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x01060004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0706090A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07080800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050908 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07040100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00060206 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02040307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02000204 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x00020001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05040402 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x02010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x05040004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06030301 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x2825262A +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x29272627 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00120012 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000012 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000812 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004045D +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2266_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2266_emc.txt new file mode 100644 index 00000000..7bea961d --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2266_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000088 +EMC_RFC_0 = 0x0000027B +EMC_RAS_0 = 0x00000060 +EMC_RP_0 = 0x00000029 +EMC_R2W_0 = 0x0000002F +EMC_W2R_0 = 0x00000028 +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000029 +EMC_WR_RCD_0 = 0x00000029 +EMC_RRD_0 = 0x00000011 +EMC_REXT_0 = 0x0000001A +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x00000029 +EMC_QRST_0 = 0x00070009 +EMC_QSAFE_0 = 0x0000003A +EMC_RDV_0 = 0x00000040 +EMC_REFRESH_0 = 0x00002245 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000017 +EMC_PDEX2RD_0 = 0x00000017 +EMC_PCHG2PDEN_0 = 0x00000004 +EMC_ACT2PDEN_0 = 0x00000020 +EMC_AR2PDEN_0 = 0x00000004 +EMC_RW2PDEN_0 = 0x00000040 +EMC_TXSR_0 = 0x0000028C +EMC_TCKE_0 = 0x00000013 +EMC_TFAW_0 = 0x00000044 +EMC_TRPAB_0 = 0x00000030 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001B +EMC_TREFBW_0 = 0x00002285 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000042 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02370020 +EMC_MRS_WAIT_CNT_0 = 0x07FF0035 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012283F +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000014 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000012 +EMC_EINPUT_DURATION_0 = 0x00000025 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000022 +EMC_TPD_0 = 0x00000011 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D180000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430021 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000042 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000040 +EMC_RDV_EARLY_0 = 0x0000003E +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186237 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000040 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000891 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004455 +EMC_TXSRDLL_0 = 0x0000028C +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000032 +EMC_TR_RDV_MASK_0 = 0x00000042 +EMC_TR_QSAFE_0 = 0x0000003A +EMC_TR_QRST_0 = 0x00070009 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x10000020 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0E0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000032 +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000013E +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000B0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002F +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000B0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000B0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000B0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00230024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x44444545 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x433F3D42 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000043 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x4143403F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x3F443B3F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000003C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x49484B4A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x474A4A3C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000048 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x3741413F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x3E3D3934 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000028 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x3F444143 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x40444040 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000042 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x3F3E3F3F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x403F3F3C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000003E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x0F0F100D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x0B0E090B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x43433E40 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x4140433D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000003E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04050606 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x03000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x05050305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x06060709 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x06060700 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x01060707 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06040000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00080307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03060408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02030604 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x04020302 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05040402 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03010001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x07050206 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x07040402 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x26252629 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x28282B29 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000013 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000813 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004046D +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000E0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2300_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2300_emc.txt new file mode 100644 index 00000000..81bab58f --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2300_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x0000008A +EMC_RFC_0 = 0x00000284 +EMC_RAS_0 = 0x00000061 +EMC_RP_0 = 0x0000002A +EMC_R2W_0 = 0x00000030 +EMC_W2R_0 = 0x00000028 +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x0000002A +EMC_WR_RCD_0 = 0x0000002A +EMC_RRD_0 = 0x00000012 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x00000028 +EMC_QRST_0 = 0x00070008 +EMC_QSAFE_0 = 0x0000003A +EMC_RDV_0 = 0x00000040 +EMC_REFRESH_0 = 0x000022CA +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000019 +EMC_PDEX2RD_0 = 0x00000019 +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000021 +EMC_AR2PDEN_0 = 0x00000003 +EMC_RW2PDEN_0 = 0x00000040 +EMC_TXSR_0 = 0x00000296 +EMC_TCKE_0 = 0x00000014 +EMC_TFAW_0 = 0x00000040 +EMC_TRPAB_0 = 0x00000031 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001B +EMC_TREFBW_0 = 0x0000230A +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000045 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x023F0021 +EMC_MRS_WAIT_CNT_0 = 0x07FF0036 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80125975 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000014 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000011 +EMC_EINPUT_DURATION_0 = 0x00000026 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000023 +EMC_TPD_0 = 0x00000012 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000042 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000040 +EMC_RDV_EARLY_0 = 0x0000003E +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x0118623F +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000040 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x000008B2 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004558 +EMC_TXSRDLL_0 = 0x00000296 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000032 +EMC_TR_RDV_MASK_0 = 0x00000042 +EMC_TR_QSAFE_0 = 0x0000003A +EMC_TR_QRST_0 = 0x00070008 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x1000001F +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0B09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000032 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000142 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A01A018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002F +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000B0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000B0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00230025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x45464747 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x45403F43 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000044 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x42444141 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x40443D40 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000003E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x4B4A4B4C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x484A4B3D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000048 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x38424341 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x403E3936 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000003B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00060305 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x01050102 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x41404141 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x4240413D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000040 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x0F10110F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x0C0F0A0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x45453F42 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x4341443F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000040 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04080807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x03010004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04090309 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03070004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08070A0C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07080800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06050000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00060306 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02050307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03000305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05040503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x07050106 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x07030503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x27252828 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x27272628 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000013 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000813 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004047E +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000B09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2333_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2333_emc.txt new file mode 100644 index 00000000..7d2c2312 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2333_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x0000008C +EMC_RFC_0 = 0x0000028E +EMC_RAS_0 = 0x00000062 +EMC_RP_0 = 0x0000002A +EMC_R2W_0 = 0x00000030 +EMC_W2R_0 = 0x00000029 +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x0000002A +EMC_WR_RCD_0 = 0x0000002A +EMC_RRD_0 = 0x00000012 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x00000028 +EMC_QRST_0 = 0x00070007 +EMC_QSAFE_0 = 0x0000003A +EMC_RDV_0 = 0x00000040 +EMC_REFRESH_0 = 0x0000234B +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000019 +EMC_PDEX2RD_0 = 0x00000019 +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000021 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000040 +EMC_TXSR_0 = 0x0000029F +EMC_TCKE_0 = 0x00000014 +EMC_TFAW_0 = 0x00000046 +EMC_TRPAB_0 = 0x00000031 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001B +EMC_TREFBW_0 = 0x0000238B +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000045 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02480021 +EMC_MRS_WAIT_CNT_0 = 0x07FF0036 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80124762 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000014 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000010 +EMC_EINPUT_DURATION_0 = 0x00000027 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000023 +EMC_TPD_0 = 0x00000012 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000042 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000040 +EMC_RDV_EARLY_0 = 0x0000003E +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186248 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000040 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080A +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x000008D2 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004653 +EMC_TXSRDLL_0 = 0x0000029F +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000032 +EMC_TR_RDV_MASK_0 = 0x00000042 +EMC_TR_QSAFE_0 = 0x0000003A +EMC_TR_QRST_0 = 0x00070007 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x1000001F +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0B0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000032 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x0000024A +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000147 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002F +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000B0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000B0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00240027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x06070707 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x06010004 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x45464443 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x42473F41 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000040 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x4C4C4D4D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x494B4D3E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000004A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x3A434442 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x41403B37 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000003D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x02070507 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03080304 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x43414243 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x4342423F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000041 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x11121311 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x0F110C0E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06060102 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x04020600 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000001 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04080807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x03000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x040A040A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02080005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08070A0C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x08070800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050808 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06050000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03060308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03010304 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05040403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06050105 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06040301 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x26262929 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x29282627 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000013 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000813 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040320 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000B0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2366_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2366_emc.txt new file mode 100644 index 00000000..cafec69c --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2366_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x0000008E +EMC_RFC_0 = 0x00000297 +EMC_RAS_0 = 0x00000064 +EMC_RP_0 = 0x0000002B +EMC_R2W_0 = 0x00000030 +EMC_W2R_0 = 0x00000029 +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x0000002B +EMC_WR_RCD_0 = 0x0000002B +EMC_RRD_0 = 0x00000012 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x0000002A +EMC_QRST_0 = 0x00070009 +EMC_QSAFE_0 = 0x0000003B +EMC_RDV_0 = 0x00000041 +EMC_REFRESH_0 = 0x000023CB +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000019 +EMC_PDEX2RD_0 = 0x00000019 +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000022 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000040 +EMC_TXSR_0 = 0x000002A9 +EMC_TCKE_0 = 0x00000014 +EMC_TFAW_0 = 0x00000047 +EMC_TRPAB_0 = 0x00000032 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001C +EMC_TREFBW_0 = 0x0000240B +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000002E +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02500022 +EMC_MRS_WAIT_CNT_0 = 0x07FF0036 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012304B +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000015 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000012 +EMC_EINPUT_DURATION_0 = 0x00000026 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000024 +EMC_TPD_0 = 0x00000012 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1E190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000043 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000041 +EMC_RDV_EARLY_0 = 0x0000003F +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186250 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000041 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080A +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x000008F2 +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000474E +EMC_TXSRDLL_0 = 0x000002A9 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000033 +EMC_TR_RDV_MASK_0 = 0x00000043 +EMC_TR_QSAFE_0 = 0x0000003B +EMC_TR_QRST_0 = 0x00070009 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x10000021 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000033 +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000014C +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000012 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xCC200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00150009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230030 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00150009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000C0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x00020007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000C0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x07080909 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x07030005 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x06080504 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x04090003 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000001 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0E0D0F0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0A0D0E00 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x3B454543 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x42413C38 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000003F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x04090608 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x05090506 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04020404 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x05040502 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x12131511 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x10110D0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000032 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x08090204 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06040801 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000002 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04050506 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x03010005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04080407 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x01050003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0707090B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07070700 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050808 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06040100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070306 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02050308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04010405 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02030102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x06040402 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06040104 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06030301 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x27252529 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x28292629 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000013 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000813 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040320 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2400_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2400_emc.txt new file mode 100644 index 00000000..a5d9c19b --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2400_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000090 +EMC_RFC_0 = 0x000002A0 +EMC_RAS_0 = 0x00000065 +EMC_RP_0 = 0x0000002C +EMC_R2W_0 = 0x00000030 +EMC_W2R_0 = 0x00000029 +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x0000002C +EMC_WR_RCD_0 = 0x0000002C +EMC_RRD_0 = 0x00000012 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x0000002A +EMC_QRST_0 = 0x00070009 +EMC_QSAFE_0 = 0x0000003B +EMC_RDV_0 = 0x00000041 +EMC_REFRESH_0 = 0x00002450 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000019 +EMC_PDEX2RD_0 = 0x00000019 +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000022 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000040 +EMC_TXSR_0 = 0x000002B2 +EMC_TCKE_0 = 0x00000014 +EMC_TFAW_0 = 0x00000048 +EMC_TRPAB_0 = 0x00000033 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001C +EMC_TREFBW_0 = 0x00002490 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000047 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02580022 +EMC_MRS_WAIT_CNT_0 = 0x07FF0036 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80121F39 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000015 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000012 +EMC_EINPUT_DURATION_0 = 0x00000026 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000024 +EMC_TPD_0 = 0x00000012 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000043 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000041 +EMC_RDV_EARLY_0 = 0x0000003F +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186258 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000041 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080A +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000914 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004850 +EMC_TXSRDLL_0 = 0x000002B2 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000033 +EMC_TR_RDV_MASK_0 = 0x00000043 +EMC_TR_QSAFE_0 = 0x0000003B +EMC_TR_QRST_0 = 0x00070009 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x10000021 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000033 +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000150 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000C0014 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0015000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230030 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0014 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0015000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000C0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000C0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00240027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0A0A0B0B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x09050307 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x06090606 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x050A0104 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0F0E1011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0C0F0F01 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x3C464745 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x44433D39 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000041 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x040A070A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x060A0607 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x05040506 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x06050503 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x14151713 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x12130F11 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000000E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x09090305 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x08050902 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03080807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x050A040A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02080005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0706090B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x06070800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06050000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00090407 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02060407 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02000304 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01020001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05030402 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x05040004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06040301 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x2724282A +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x2A27262B +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000A000A +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000014 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000814 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000404B0 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2433_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2433_emc.txt new file mode 100644 index 00000000..6575dd80 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2433_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000092 +EMC_RFC_0 = 0x000002AA +EMC_RAS_0 = 0x00000067 +EMC_RP_0 = 0x0000002C +EMC_R2W_0 = 0x00000030 +EMC_W2R_0 = 0x0000002A +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x0000002C +EMC_WR_RCD_0 = 0x0000002C +EMC_RRD_0 = 0x00000013 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x0000002A +EMC_QRST_0 = 0x00070008 +EMC_QSAFE_0 = 0x0000003B +EMC_RDV_0 = 0x00000041 +EMC_REFRESH_0 = 0x000024D1 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001A +EMC_PDEX2RD_0 = 0x0000001A +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000023 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000040 +EMC_TXSR_0 = 0x000002BC +EMC_TCKE_0 = 0x00000015 +EMC_TFAW_0 = 0x00000049 +EMC_TRPAB_0 = 0x00000034 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001C +EMC_TREFBW_0 = 0x00002511 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000048 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02610023 +EMC_MRS_WAIT_CNT_0 = 0x07FF0036 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80122A41 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000015 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000011 +EMC_EINPUT_DURATION_0 = 0x00000027 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000025 +EMC_TPD_0 = 0x00000013 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000043 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000041 +EMC_RDV_EARLY_0 = 0x0000003F +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186261 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000041 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000934 +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000494B +EMC_TXSRDLL_0 = 0x000002BC +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000033 +EMC_TR_RDV_MASK_0 = 0x00000043 +EMC_TR_QSAFE_0 = 0x0000003B +EMC_TR_QRST_0 = 0x00070008 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x10000021 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0B +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000033 +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000155 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC0200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000C0014 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0015000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230030 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0014 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0015000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000C0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000C0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0B0C0C0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x0B060409 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x080B0807 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x070C0306 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x10101112 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0D101102 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000000E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x3D474846 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x45443F3A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000041 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x050A080A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x060A0707 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000002E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x07060607 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x07070703 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x37373735 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x13151012 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x0B0B0506 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x09070A03 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04080806 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x03080407 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x01050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x06060709 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x06070800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x05030000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00080407 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02060408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03020405 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x03020102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05020302 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x02010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06040105 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x07030401 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x2723242A +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x25262426 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00050005 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000014 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000814 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000404C1 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0B +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2466_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2466_emc.txt new file mode 100644 index 00000000..44374289 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2466_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000094 +EMC_RFC_0 = 0x000002B3 +EMC_RAS_0 = 0x00000068 +EMC_RP_0 = 0x0000002D +EMC_R2W_0 = 0x00000030 +EMC_W2R_0 = 0x0000002A +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x0000002D +EMC_WR_RCD_0 = 0x0000002D +EMC_RRD_0 = 0x00000013 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x0000002A +EMC_QRST_0 = 0x00070008 +EMC_QSAFE_0 = 0x0000003B +EMC_RDV_0 = 0x00000041 +EMC_REFRESH_0 = 0x00002551 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000010 +EMC_PDEX2RD_0 = 0x0000001A +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000023 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000040 +EMC_TXSR_0 = 0x000002C5 +EMC_TCKE_0 = 0x00000015 +EMC_TFAW_0 = 0x0000004A +EMC_TRPAB_0 = 0x00000034 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001C +EMC_TREFBW_0 = 0x00002591 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000049 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02690023 +EMC_MRS_WAIT_CNT_0 = 0x07FF0036 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012001A +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000015 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000011 +EMC_EINPUT_DURATION_0 = 0x00000027 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000025 +EMC_TPD_0 = 0x00000013 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000043 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000041 +EMC_RDV_EARLY_0 = 0x0000003F +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186269 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000041 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080A +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000954 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004A46 +EMC_TXSRDLL_0 = 0x000002C5 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000033 +EMC_TR_RDV_MASK_0 = 0x00000043 +EMC_TR_QSAFE_0 = 0x0000003B +EMC_TR_QRST_0 = 0x00070008 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x10000021 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000033 +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000015A +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x20000100 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x00082000 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000C0014 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230030 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0014 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000C0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000C0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00270027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0C0D0E0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x0B07050A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x0A0C0909 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x080D0407 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x11111313 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0E111303 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x3F494A48 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x4746413C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000043 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x070C090B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x080C0808 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x09070909 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x09090905 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x18181A16 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x14161214 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x0D0D0708 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x2D2B2E29 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04080807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x05050305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x01050003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0706090C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07070800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00040505 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06040100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00050305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03060409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04010404 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02020102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05050504 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06040005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x07030302 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x2724232A +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x28292628 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000A000A +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000014 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1E181E18 +EMC_PMACRO_CA_TX_DRV_0 = 0x1E181E18 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000814 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000404D1 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2500_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2500_emc.txt new file mode 100644 index 00000000..d349d28d --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2500_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000096 +EMC_RFC_0 = 0x000002BC +EMC_RAS_0 = 0x00000069 +EMC_RP_0 = 0x0000002D +EMC_R2W_0 = 0x00000031 +EMC_W2R_0 = 0x0000002A +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x0000002D +EMC_WR_RCD_0 = 0x0000002D +EMC_RRD_0 = 0x00000013 +EMC_REXT_0 = 0x0000001A +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x00000029 +EMC_QRST_0 = 0x00070007 +EMC_QSAFE_0 = 0x0000003B +EMC_RDV_0 = 0x00000041 +EMC_REFRESH_0 = 0x000025D6 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001A +EMC_PDEX2RD_0 = 0x0000001A +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000023 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000040 +EMC_TXSR_0 = 0x000002CF +EMC_TCKE_0 = 0x00000015 +EMC_TFAW_0 = 0x0000004B +EMC_TRPAB_0 = 0x00000035 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001D +EMC_TREFBW_0 = 0x00002616 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000049 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02710023 +EMC_MRS_WAIT_CNT_0 = 0x07FF0036 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012ED06 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000016 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000010 +EMC_EINPUT_DURATION_0 = 0x00000028 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000026 +EMC_TPD_0 = 0x00000013 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000043 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000041 +EMC_RDV_EARLY_0 = 0x0000003F +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x0118614D +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000041 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080A +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000975 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004B49 +EMC_TXSRDLL_0 = 0x000002CF +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000033 +EMC_TR_RDV_MASK_0 = 0x00000043 +EMC_TR_QSAFE_0 = 0x0000003B +EMC_TR_QRST_0 = 0x00070007 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x10000020 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000033 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000015E +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x88204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230030 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x00060000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000C0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00270027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00230025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0F0F1010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x0D09070C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000000E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x0B0D0A0A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x090E0508 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x12121414 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0F121404 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000030 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x252C2D2C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x4847423D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000045 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x090D0B0E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0A0E0A0A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x0B090A0A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x0A0A0A07 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x1A1A1B19 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x16181415 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x0F0E070A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x0C090D07 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03080806 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04080407 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x01050003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x07060A0C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x06070700 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x01060806 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07050100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00060307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02040208 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02040704 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x04020403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x06040403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06040006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x07030402 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x24232627 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x27292B27 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000A000A +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000015 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000814 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000404E2 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2533_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2533_emc.txt new file mode 100644 index 00000000..54c6b84d --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2533_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000098 +EMC_RFC_0 = 0x000002C6 +EMC_RAS_0 = 0x0000006B +EMC_RP_0 = 0x0000002E +EMC_R2W_0 = 0x00000031 +EMC_W2R_0 = 0x0000002B +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x0000001D +EMC_WR_RCD_0 = 0x0000002E +EMC_RRD_0 = 0x00000013 +EMC_REXT_0 = 0x0000001C +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x00000029 +EMC_QRST_0 = 0x00080005 +EMC_QSAFE_0 = 0x0000003C +EMC_RDV_0 = 0x00000041 +EMC_REFRESH_0 = 0x00002657 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001A +EMC_PDEX2RD_0 = 0x0000001A +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000024 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000040 +EMC_TXSR_0 = 0x000002D9 +EMC_TCKE_0 = 0x00000015 +EMC_TFAW_0 = 0x0000004C +EMC_TRPAB_0 = 0x00000036 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001D +EMC_TREFBW_0 = 0x00002697 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000004A +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x027A0024 +EMC_MRS_WAIT_CNT_0 = 0x07FF0036 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012D7F0 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000016 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000F +EMC_EINPUT_DURATION_0 = 0x00000029 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000026 +EMC_TPD_0 = 0x00000013 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D180000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000043 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000041 +EMC_RDV_EARLY_0 = 0x0000003F +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x0118627A +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000041 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000995 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004C44 +EMC_TXSRDLL_0 = 0x000002D9 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000033 +EMC_TR_RDV_MASK_0 = 0x00000043 +EMC_TR_QSAFE_0 = 0x0000003C +EMC_TR_QRST_0 = 0x00080005 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x1000001F +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0B +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000033 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000163 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x000E0006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000C0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000C0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x10111111 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x0F0A080D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x0E0F0D0B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x0C10070A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000029 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x14141616 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x12141606 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x414C4D4B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x4948433E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000046 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x0A0F0C0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0A0F0B0B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000000E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x2D2C2C2D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x0C0B0C08 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x1B1C1D1B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x181A1517 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000016 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x0F10090B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x0E0B0E08 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04080808 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x03010006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04080408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0706090B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07070800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050908 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x05040000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03060308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03000304 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05030403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x07040106 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x07040402 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x25242428 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x27282627 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000A000A +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000015 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000815 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000404F3 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0B +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2566_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2566_emc.txt new file mode 100644 index 00000000..536e0cb1 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2566_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x0000009A +EMC_RFC_0 = 0x000002CF +EMC_RAS_0 = 0x0000006C +EMC_RP_0 = 0x0000002F +EMC_R2W_0 = 0x00000031 +EMC_W2R_0 = 0x0000002B +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x0000002F +EMC_WR_RCD_0 = 0x0000002F +EMC_RRD_0 = 0x00000014 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x0000002A +EMC_QRST_0 = 0x00080006 +EMC_QSAFE_0 = 0x0000003C +EMC_RDV_0 = 0x00000042 +EMC_REFRESH_0 = 0x000026D7 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001B +EMC_PDEX2RD_0 = 0x0000001B +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000024 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000040 +EMC_TXSR_0 = 0x000002E2 +EMC_TCKE_0 = 0x00000016 +EMC_TFAW_0 = 0x0000004D +EMC_TRPAB_0 = 0x00000036 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001D +EMC_TREFBW_0 = 0x00002717 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000004C +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02820024 +EMC_MRS_WAIT_CNT_0 = 0x07FF0036 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012CAE3 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000016 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000010 +EMC_EINPUT_DURATION_0 = 0x00000029 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000027 +EMC_TPD_0 = 0x00000014 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D180000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000044 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000042 +EMC_RDV_EARLY_0 = 0x00000040 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186282 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000042 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x000009B5 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004D3F +EMC_TXSRDLL_0 = 0x000002E2 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000034 +EMC_TR_RDV_MASK_0 = 0x00000044 +EMC_TR_QSAFE_0 = 0x0000003C +EMC_TR_QRST_0 = 0x00080006 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x10000020 +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000034 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000168 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x88204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230031 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000D0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000D0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00270027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x11111313 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x100C0A0E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x10110E0E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x0D12090C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x17161818 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x13171808 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x020D0E0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x0A090500 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x0C110E11 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0D110D0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x0D0C0C0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x0D0D0D0A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x1C1C1E1B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x191B1618 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000017 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x11120B0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x0F0C1009 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04080807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04080408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0706090B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x06070700 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00060A09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x08060100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00080408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03060308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03000304 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x00020001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x06030403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x07050106 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x08050402 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x2724252B +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x272A2627 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000A000A +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000015 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000815 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040503 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2600_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2600_emc.txt new file mode 100644 index 00000000..09acdd0e --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2600_emc.txt @@ -0,0 +1,87 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +emc_cfg = 0xF3200000 +emc_rc = 0x0000009C +emc_rfc = 0x000002D8 +emc_ras = 0x0000006E +emc_rp = 0x0000002F +emc_r2w = 0x00000031 +emc_w2r = 0x0000002B +emc_r2p = 0x0000000E +emc_w2p = 0x00000033 +emc_rd_rcd = 0x0000002F +emc_wr_rcd = 0x0000002F +emc_rrd = 0x00000014 +emc_rext = 0x0000001B +emc_qsafe = 0x0000003C +emc_refresh = 0x0000275C +emc_burst_refresh_num = 0x00000000 +emc_pdex2wr = 0x0000001B +emc_pdex2rd = 0x0000001B +emc_pchg2pden = 0x00000005 +emc_act2pden = 0x00000025 +emc_ar2pden = 0x00000005 +emc_rw2pden = 0x00000040 +emc_txsr = 0x000002EC +emc_tcke = 0x00000016 +emc_tfaw = 0x0000004E +emc_trpab = 0x00000037 +emc_tclkstable = 0x00000004 +emc_tclkstop = 0x0000001E +emc_trefbw = 0x0000279C +emc_tppd = 0x00000004 +emc_odt_write = 0x00000000 +emc_pdex2mrr = 0x0000004C +emc_wext = 0x00000019 +emc_rfc_slr = 0x00000000 +emc_mrs_wait_cnt2 = 0x028A0025 +emc_mrs_wait_cnt = 0x07FF0037 +emc_mrs = 0x00000000 +emc_emrs = 0x00000000 +emc_mrw = 0x00170040 +emc_fbio_spare = 0x00000012 +emc_fbio_cfg5 = 0x9160A00D +emc_pdex2cke = 0x00000003 +emc_cke2pden = 0x00000017 +emc_r2r = 0x00000000 +emc_einput = 0x00000010 +emc_einput_duration = 0x00000029 +emc_puterm_extra = 0x00000001 +emc_tckesr = 0x00000027 +emc_tpd = 0x00000014 +emc_cfg_2 = 0x0011083D +emc_cfg_dig_dll = 0x002C03A9 +emc_cfg_dig_dll_period = 0x00008000 +emc_rdv_mask = 0x00000044 +emc_wdv_mask = 0x00000010 +emc_rdv_early_mask = 0x00000042 +emc_rdv_early = 0x00000040 +emc_fdpd_ctrl_dq = 0x8020221F +emc_fdpd_ctrl_cmd = 0x0220F40F +emc_sel_dpd_ctrl = 0x0004000C +emc_pre_refresh_req_cnt = 0x000009D7 +emc_dyn_self_ref_control = 0x80004E41 +emc_txsrdll = 0x000002EC +emc_ibdly = 0x10000020 +emc_obdly = 0x10000002 +emc_txdsrvttgen = 0x00000000 +emc_we_duration = 0x0000000E +emc_ws_duration = 0x00000008 +emc_wev = 0x0000000C +emc_cfg_3 = 0x00000040 +emc_wdv_chk = 0x00000006 +emc_cfg_pipe_2 = 0x00000000 +emc_cfg_pipe_1 = 0x0FFF0000 +emc_cfg_pipe = 0x0FFF0000 +emc_quse_width = 0x0000000B +emc_puterm_width = 0x80000000 +emc_fbio_cfg7 = 0x00003BFF +emc_rfcpb = 0x0000016C +emc_ccdmw = 0x00000020 +emc_config_sample_delay = 0x00000020 +emc_wdv = 0x00000010 +emc_quse = 0x0000002A +emc_qrst = 0x00080006 +emc_rdv = 0x00000042 +emc_wsv = 0x0000000E +emc_qpop = 0x00000034 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2633_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2633_emc.txt new file mode 100644 index 00000000..765a9849 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2633_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x0000009E +EMC_RFC_0 = 0x000002E2 +EMC_RAS_0 = 0x0000006F +EMC_RP_0 = 0x00000030 +EMC_R2W_0 = 0x00000031 +EMC_W2R_0 = 0x0000002C +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000030 +EMC_WR_RCD_0 = 0x00000030 +EMC_RRD_0 = 0x00000014 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x0000002A +EMC_QRST_0 = 0x00080005 +EMC_QSAFE_0 = 0x0000003D +EMC_RDV_0 = 0x00000042 +EMC_REFRESH_0 = 0x000027DD +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001B +EMC_PDEX2RD_0 = 0x0000001B +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000025 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000040 +EMC_TXSR_0 = 0x000002F5 +EMC_TCKE_0 = 0x00000016 +EMC_TFAW_0 = 0x0000004F +EMC_TRPAB_0 = 0x00000038 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001E +EMC_TREFBW_0 = 0x0000281D +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000004D +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02930025 +EMC_MRS_WAIT_CNT_0 = 0x07FF0037 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80040101 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000017 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000F +EMC_EINPUT_DURATION_0 = 0x0000002A +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000028 +EMC_TPD_0 = 0x00000014 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000044 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000042 +EMC_RDV_EARLY_0 = 0x00000040 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186293 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000042 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x000009F7 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004F3C +EMC_TXSRDLL_0 = 0x000002F5 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000034 +EMC_TR_RDV_MASK_0 = 0x00000044 +EMC_TR_QSAFE_0 = 0x0000003D +EMC_TR_QRST_0 = 0x00080005 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030E +EMC_IBDLY_0 = 0x10000020 +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0D08 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000034 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000171 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000012 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC0200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000D0016 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0017000B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x00200027 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00230026 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230031 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000D0016 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0017000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000D0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x00080000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00270029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x15151516 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x130F0D12 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x10141010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x0F150B0E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x1A1A1C1B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x171B1B0A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x050F110E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x0D0C0701 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x0E131114 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x10151011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x100E0F10 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x100F100C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000000E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x201F211F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x1C1E191C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000001A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x14150E0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x1110130B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000000E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x05080909 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04010007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04090508 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02060004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x07080A0F +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0A0A0900 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00070B09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07070200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00080408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03050409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04030606 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x04040304 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x06030403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x07040106 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x08040502 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x27262428 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x26262627 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00170017 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000016 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000816 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040525 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000D08 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2666_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2666_emc.txt new file mode 100644 index 00000000..357686e0 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2666_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000A0 +EMC_RFC_0 = 0x000002EB +EMC_RAS_0 = 0x00000070 +EMC_RP_0 = 0x00000030 +EMC_R2W_0 = 0x00000031 +EMC_W2R_0 = 0x0000002C +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000030 +EMC_WR_RCD_0 = 0x00000030 +EMC_RRD_0 = 0x00000014 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x0000002A +EMC_QRST_0 = 0x00080005 +EMC_QSAFE_0 = 0x0000003D +EMC_RDV_0 = 0x00000042 +EMC_REFRESH_0 = 0x0000285D +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001B +EMC_PDEX2RD_0 = 0x0000001B +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000026 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000040 +EMC_TXSR_0 = 0x000002FF +EMC_TCKE_0 = 0x00000016 +EMC_TFAW_0 = 0x00000050 +EMC_TRPAB_0 = 0x00000038 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001E +EMC_TREFBW_0 = 0x0000289D +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000004D +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x029B0026 +EMC_MRS_WAIT_CNT_0 = 0x07FF0037 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80129EB6 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000017 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000F +EMC_EINPUT_DURATION_0 = 0x0000002A +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000028 +EMC_TPD_0 = 0x00000014 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000035 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000042 +EMC_RDV_EARLY_0 = 0x00000040 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x0118629B +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000042 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000A17 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005037 +EMC_TXSRDLL_0 = 0x000002FF +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000034 +EMC_TR_RDV_MASK_0 = 0x00000044 +EMC_TR_QSAFE_0 = 0x0000003D +EMC_TR_QRST_0 = 0x00080005 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030E +EMC_IBDLY_0 = 0x10000020 +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000034 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000176 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000D0016 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0017000B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230032 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000D0016 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0017000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000D0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000D0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00270029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00230027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x16171717 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x15100D14 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x12151211 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x11160C10 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000000E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x33323333 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x181B1C0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x262C2D2C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x2A2A2624 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x10161315 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x11161212 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x11101112 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1211110E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x21222320 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x1E201C1D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000001C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x16160F11 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x1410140D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x05090909 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x050B050B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03080005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08080B0F +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0A0A0A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00080B08 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07040100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00090508 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03080509 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04020506 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x03030202 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05020403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x02010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x08050208 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x09050604 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x25252729 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x25262628 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00170017 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000016 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000816 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040535 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2700_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2700_emc.txt new file mode 100644 index 00000000..a50c104d --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2700_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000A2 +EMC_RFC_0 = 0x000002F4 +EMC_RAS_0 = 0x00000072 +EMC_RP_0 = 0x00000031 +EMC_R2W_0 = 0x00000031 +EMC_W2R_0 = 0x0000002C +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000031 +EMC_WR_RCD_0 = 0x00000031 +EMC_RRD_0 = 0x00000015 +EMC_REXT_0 = 0x0000001C +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x00000029 +EMC_QRST_0 = 0x00080004 +EMC_QSAFE_0 = 0x0000003E +EMC_RDV_0 = 0x00000042 +EMC_REFRESH_0 = 0x000028E2 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001C +EMC_PDEX2RD_0 = 0x0000001C +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000026 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000040 +EMC_TXSR_0 = 0x00000309 +EMC_TCKE_0 = 0x00000017 +EMC_TFAW_0 = 0x00000051 +EMC_TRPAB_0 = 0x00000039 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001E +EMC_TREFBW_0 = 0x00002922 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000004F +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02A30026 +EMC_MRS_WAIT_CNT_0 = 0x07FF0037 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80128FA7 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000017 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000E +EMC_EINPUT_DURATION_0 = 0x0000002B +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000029 +EMC_TPD_0 = 0x00000015 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000044 +EMC_WDV_MASK_0 = 0x0000000E +EMC_RDV_EARLY_MASK_0 = 0x00000042 +EMC_RDV_EARLY_0 = 0x00000040 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x00310640 +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862A3 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000042 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000A38 +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000513A +EMC_TXSRDLL_0 = 0x00000309 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000034 +EMC_TR_RDV_MASK_0 = 0x00000044 +EMC_TR_QSAFE_0 = 0x0000003E +EMC_TR_QRST_0 = 0x00080004 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030E +EMC_IBDLY_0 = 0x1000001F +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000034 +EMC_QUSE_WIDTH_0 = 0x0000000C +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000017A +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x88200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000E0016 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0018000B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230032 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000E0016 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0018000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000D0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000D0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00270029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x17171818 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x16110F15 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000016 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x14171313 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x2B2E282B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x1C1B1E1E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x191C1D0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000001A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x08131412 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x100F0A04 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x11171517 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x12171313 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000017 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x13121213 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1312130F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x23232422 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x1F221C1F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000001D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x18181112 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x1512160E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0509090A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04010007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x050A050A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x04080005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08080B0F +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0A0A0A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00070A08 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x09060000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03060308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02020203 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x03030202 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05050503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x03020003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x03020200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x24252628 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x22272725 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x00080008 +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00180018 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x0000000D +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000816 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040546 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2733_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2733_emc.txt new file mode 100644 index 00000000..1763a67a --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2733_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000A4 +EMC_RFC_0 = 0x000002FE +EMC_RAS_0 = 0x00000073 +EMC_RP_0 = 0x00000032 +EMC_R2W_0 = 0x00000031 +EMC_W2R_0 = 0x0000002D +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000032 +EMC_WR_RCD_0 = 0x00000032 +EMC_RRD_0 = 0x00000015 +EMC_REXT_0 = 0x0000001C +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x00000029 +EMC_QRST_0 = 0x00080003 +EMC_QSAFE_0 = 0x0000003F +EMC_RDV_0 = 0x00000042 +EMC_REFRESH_0 = 0x00002963 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001C +EMC_PDEX2RD_0 = 0x0000001C +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000027 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000040 +EMC_TXSR_0 = 0x00000312 +EMC_TCKE_0 = 0x00000017 +EMC_TFAW_0 = 0x00000052 +EMC_TRPAB_0 = 0x0000003A +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x000029A3 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000050 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02AC0027 +EMC_MRS_WAIT_CNT_0 = 0x07FF0037 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80128198 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000018 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000D +EMC_EINPUT_DURATION_0 = 0x0000002C +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000029 +EMC_TPD_0 = 0x00000015 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000044 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000042 +EMC_RDV_EARLY_0 = 0x00000040 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862AC +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000042 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000A58 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005235 +EMC_TXSRDLL_0 = 0x00000312 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000034 +EMC_TR_RDV_MASK_0 = 0x00000044 +EMC_TR_QSAFE_0 = 0x0000003F +EMC_TR_QRST_0 = 0x00080003 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030E +EMC_IBDLY_0 = 0x1000001F +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000034 +EMC_QUSE_WIDTH_0 = 0x0000000C +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000017F +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000E0017 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x000B0005 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230032 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000E0017 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0018000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000D0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000D0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00280029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00230025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00210028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x191A1A1A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x18131016 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000018 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x16181515 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x14190F13 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000029 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x1D1E1F1E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x1A1D1E0E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000031 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x09141513 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x12100B05 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000000E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x13191619 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x141A1515 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000018 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x14131414 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x14141410 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x25252623 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x20231E20 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000001F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x1A191114 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x16131811 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x05090909 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04010007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x05090509 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03070005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08080A0F +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0A0A0A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00070C09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x09080200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00060308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03050208 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02000102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x00020001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05050503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x05030103 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x07050005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x07030401 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x24232426 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x24262824 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00170017 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000E000E +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00180018 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000017 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000816 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040557 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2766_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2766_emc.txt new file mode 100644 index 00000000..975cbc5d --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2766_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000A6 +EMC_RFC_0 = 0x00000307 +EMC_RAS_0 = 0x00000075 +EMC_RP_0 = 0x00000032 +EMC_R2W_0 = 0x00000031 +EMC_W2R_0 = 0x00000021 +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000032 +EMC_WR_RCD_0 = 0x00000032 +EMC_RRD_0 = 0x00000015 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x0000002B +EMC_QRST_0 = 0x00080005 +EMC_QSAFE_0 = 0x00000033 +EMC_RDV_0 = 0x00000043 +EMC_REFRESH_0 = 0x000029E3 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001C +EMC_PDEX2RD_0 = 0x0000001C +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000027 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000040 +EMC_TXSR_0 = 0x0000031C +EMC_TCKE_0 = 0x00000017 +EMC_TFAW_0 = 0x00000053 +EMC_TRPAB_0 = 0x0000003B +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002A23 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000050 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02B40027 +EMC_MRS_WAIT_CNT_0 = 0x07FF0037 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012738A +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000018 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000F +EMC_EINPUT_DURATION_0 = 0x0000002B +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002A +EMC_TPD_0 = 0x00000015 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000045 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000043 +EMC_RDV_EARLY_0 = 0x00000041 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862B4 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000043 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000A78 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005330 +EMC_TXSRDLL_0 = 0x0000031C +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000035 +EMC_TR_RDV_MASK_0 = 0x00000045 +EMC_TR_QSAFE_0 = 0x0000003E +EMC_TR_QRST_0 = 0x00080005 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030E +EMC_IBDLY_0 = 0x10000021 +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000035 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000184 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000012 +EMC_CMD_BRLSHFT_3_0 = 0x00000012 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x88200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000E0017 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0018000B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230032 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000E0017 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0018000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000E0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000E0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00280029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00210028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x1A1A1B1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x18141218 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x171B1717 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x161B1115 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x1F1E2121 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x1B1F200F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000001C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x0B161715 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x13110D07 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x151B181B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x161B1717 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x16141617 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x15151611 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x27262725 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x22251F22 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000020 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x1B1A1314 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x17141811 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0509090A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x05000007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x070A060A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x04070005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08090B0F +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0B0A0A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x01080C0A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x09070200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02040305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03020405 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x03020202 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x08030404 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x05030103 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x07060105 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06040401 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x25242528 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x25252423 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00170017 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x00080008 +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00180018 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000017 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000817 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040567 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2800_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2800_emc.txt new file mode 100644 index 00000000..5a7bbdb4 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2800_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000A8 +EMC_RFC_0 = 0x00000310 +EMC_RAS_0 = 0x00000076 +EMC_RP_0 = 0x00000033 +EMC_R2W_0 = 0x00000031 +EMC_W2R_0 = 0x0000002D +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000033 +EMC_WR_RCD_0 = 0x00000033 +EMC_RRD_0 = 0x00000015 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x0000002B +EMC_QRST_0 = 0x00080005 +EMC_QSAFE_0 = 0x0000003E +EMC_RDV_0 = 0x00000043 +EMC_REFRESH_0 = 0x00002A68 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001C +EMC_PDEX2RD_0 = 0x0000001C +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000028 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000041 +EMC_TXSR_0 = 0x00000325 +EMC_TCKE_0 = 0x00000017 +EMC_TFAW_0 = 0x00000054 +EMC_TRPAB_0 = 0x0000003B +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002AA8 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000051 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02BC0028 +EMC_MRS_WAIT_CNT_0 = 0x07FF0037 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012667C +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000018 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000F +EMC_EINPUT_DURATION_0 = 0x0000002B +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002A +EMC_TPD_0 = 0x00000015 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000045 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000043 +EMC_RDV_EARLY_0 = 0x00000041 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862BC +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000043 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F070B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000A9A +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005432 +EMC_TXSRDLL_0 = 0x00000325 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000035 +EMC_TR_RDV_MASK_0 = 0x00000045 +EMC_TR_QSAFE_0 = 0x0000003E +EMC_TR_QRST_0 = 0x00080005 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030F +EMC_IBDLY_0 = 0x10000016 +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0B09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000035 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000188 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x80204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x0008000D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0019000B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x00200026 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230032 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x0008000D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0019000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000E0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000E0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00250028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x0028002A +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00210028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x1C1B1C1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x1A151319 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000001A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x171B1717 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x161B1115 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x21202222 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x1D202211 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000024 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x1B212120 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x15130D08 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x161B191C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x171B1818 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000001B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x17161617 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x17161713 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x27282926 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x24262024 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000021 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x1B1C1416 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x18161A13 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0409090A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x05010006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x090C060C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x060A0007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x09090C10 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0B0A0B00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00080C0A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x09060100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x04070308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03000205 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x09030405 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x06030104 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x07050106 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x07030401 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x23232527 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x25272222 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00170017 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x00080008 +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00190019 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x0000000D +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x070B070B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000817 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040578 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000B09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2833_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2833_emc.txt new file mode 100644 index 00000000..00429836 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2833_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000AA +EMC_RFC_0 = 0x0000031A +EMC_RAS_0 = 0x00000077 +EMC_RP_0 = 0x00000033 +EMC_R2W_0 = 0x00000031 +EMC_W2R_0 = 0x0000002E +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000033 +EMC_WR_RCD_0 = 0x00000033 +EMC_RRD_0 = 0x00000016 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x0000002B +EMC_QRST_0 = 0x00080004 +EMC_QSAFE_0 = 0x0000003F +EMC_RDV_0 = 0x00000043 +EMC_REFRESH_0 = 0x00002AE9 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001D +EMC_PDEX2RD_0 = 0x0000001D +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000028 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000041 +EMC_TXSR_0 = 0x0000032F +EMC_TCKE_0 = 0x00000018 +EMC_TFAW_0 = 0x00000055 +EMC_TRPAB_0 = 0x0000003C +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002B29 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000052 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02C50028 +EMC_MRS_WAIT_CNT_0 = 0x07FF0037 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80125A71 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000019 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000E +EMC_EINPUT_DURATION_0 = 0x0000002C +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002B +EMC_TPD_0 = 0x00000016 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000045 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000043 +EMC_RDV_EARLY_0 = 0x00000041 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862C5 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000043 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000ABA +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000552D +EMC_TXSRDLL_0 = 0x0000032F +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000035 +EMC_TR_RDV_MASK_0 = 0x00000045 +EMC_TR_QSAFE_0 = 0x0000003F +EMC_TR_QRST_0 = 0x00080004 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030F +EMC_IBDLY_0 = 0x10000021 +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0D08 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000035 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000018D +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC0204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000E0017 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0019000B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230033 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000E0017 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0019000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000E0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000E0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00240028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00280029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00210028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x1C1C1C1E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x2D2A292D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000001A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x191C1A19 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x2B2E292A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000029 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x22232524 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x2F313328 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000030 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x0D181917 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x15150F0A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x171D1B1E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x21232121 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000002E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x1918181A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x19171915 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000017 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x2A2B2C28 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x26272225 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000023 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x1D1D1617 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x1A171B15 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000017 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x050A0A0A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x06000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x080B060B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08080B0F +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x09090A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00080C09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x09070200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00090408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x01020304 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03000305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02020001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x09040504 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x05030104 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x03020003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x05020302 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x23232427 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x24262325 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00170017 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x00080008 +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x000E000E +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000017 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000817 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040589 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000D08 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2866_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2866_emc.txt new file mode 100644 index 00000000..f15f388d --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2866_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000AC +EMC_RFC_0 = 0x00000323 +EMC_RAS_0 = 0x00000079 +EMC_RP_0 = 0x00000034 +EMC_R2W_0 = 0x00000031 +EMC_W2R_0 = 0x0000002E +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000034 +EMC_WR_RCD_0 = 0x00000034 +EMC_RRD_0 = 0x00000016 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x0000002B +EMC_QRST_0 = 0x00080004 +EMC_QSAFE_0 = 0x0000003F +EMC_RDV_0 = 0x00000043 +EMC_REFRESH_0 = 0x00002B69 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001E +EMC_PDEX2RD_0 = 0x0000001E +EMC_PCHG2PDEN_0 = 0x00000006 +EMC_ACT2PDEN_0 = 0x00000029 +EMC_AR2PDEN_0 = 0x00000006 +EMC_RW2PDEN_0 = 0x00000041 +EMC_TXSR_0 = 0x00000338 +EMC_TCKE_0 = 0x00000018 +EMC_TFAW_0 = 0x00000056 +EMC_TRPAB_0 = 0x0000003D +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002BA9 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000054 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02CD0029 +EMC_MRS_WAIT_CNT_0 = 0x07FF0038 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012475D +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000004 +EMC_CKE2PDEN_0 = 0x00000019 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0000 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000014 +EMC_EINPUT_DURATION_0 = 0x0000001C +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002B +EMC_TPD_0 = 0x00000016 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430020 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000045 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000043 +EMC_RDV_EARLY_0 = 0x00000041 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862CD +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000043 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000ADA +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005628 +EMC_TXSRDLL_0 = 0x00000338 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000035 +EMC_TR_RDV_MASK_0 = 0x00000045 +EMC_TR_QSAFE_0 = 0x0000003F +EMC_TR_QRST_0 = 0x00080004 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030F +EMC_IBDLY_0 = 0x10000021 +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0F09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000035 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000192 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000012 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xCC200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x0008000D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0019000C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230033 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000F0018 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0019000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0004000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000E0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0004000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000E0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00250028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00280029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00230028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x1F1F1F20 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x1D19161D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000001D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x1B1D1B1B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x191D1518 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000016 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x25242625 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x21242513 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000022 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x0E191A19 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x1816100B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x181F1C1F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x191E1A1A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000001D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x1B191A1B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1A191B16 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x2B2B2D2A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x27282326 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000024 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x1E1F171A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x2D2B2E2A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000018 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03050606 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x03000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x0A0C050C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x060A0007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x09090B0F +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0A0A0A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00080C09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x09070100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0407040A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03010305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02030001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x0A040505 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x06030104 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x09060109 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x0A040805 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x24242327 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x25252225 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00180018 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000F000F +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00060006 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x000E000E +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000018 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000817 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040599 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C08 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2900_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2900_emc.txt new file mode 100644 index 00000000..4c42fc13 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2900_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000AE +EMC_RFC_0 = 0x0000032C +EMC_RAS_0 = 0x0000007A +EMC_RP_0 = 0x00000035 +EMC_R2W_0 = 0x00000032 +EMC_W2R_0 = 0x0000002E +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000035 +EMC_WR_RCD_0 = 0x00000035 +EMC_RRD_0 = 0x00000016 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x0000002B +EMC_QRST_0 = 0x00080004 +EMC_QSAFE_0 = 0x0000003F +EMC_RDV_0 = 0x00000043 +EMC_REFRESH_0 = 0x00002BEE +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001E +EMC_PDEX2RD_0 = 0x0000001E +EMC_PCHG2PDEN_0 = 0x00000006 +EMC_ACT2PDEN_0 = 0x00000029 +EMC_AR2PDEN_0 = 0x00000006 +EMC_RW2PDEN_0 = 0x00000041 +EMC_TXSR_0 = 0x00000342 +EMC_TCKE_0 = 0x00000018 +EMC_TFAW_0 = 0x00000057 +EMC_TRPAB_0 = 0x0000003D +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002C2E +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000055 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02D50029 +EMC_MRS_WAIT_CNT_0 = 0x07FF0038 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80124258 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000004 +EMC_CKE2PDEN_0 = 0x00000019 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000E +EMC_EINPUT_DURATION_0 = 0x0000002C +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002C +EMC_TPD_0 = 0x00000016 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000045 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000043 +EMC_RDV_EARLY_0 = 0x00000041 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862D5 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000043 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F070B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000AFB +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000572B +EMC_TXSRDLL_0 = 0x00000342 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000035 +EMC_TR_RDV_MASK_0 = 0x00000045 +EMC_TR_QSAFE_0 = 0x0000003F +EMC_TR_QRST_0 = 0x00080004 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030F +EMC_IBDLY_0 = 0x10000021 +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0D09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000035 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000196 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x80204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000F0018 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0019000C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230033 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000F0018 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0019000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0004000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000E0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x00010006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x00060000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00250028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x0029002A +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00200027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x20202021 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x1E19171E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000001E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x1B1E1B1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x1A1E1519 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000016 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x26262827 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x22252616 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000024 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x0F1A1B1A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x1717110B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x181F1C1F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x1A1E1B1A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000001D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x1B1A1B1B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1A1A1B16 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x2C2D2E2B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x292B2428 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000025 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x1F20171A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x1C191E16 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000017 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x050A0A0B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x02000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x080C050C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x06060709 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x06070700 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x01060707 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x0A090300 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0308040A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03000206 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x00020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x08040504 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04030004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x09060108 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x09040704 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x25212426 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x22252123 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00180018 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000F000F +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00190019 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000018 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x0000080D +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000405AA +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000D09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2933_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2933_emc.txt new file mode 100644 index 00000000..fa0b8a78 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2933_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000B0 +EMC_RFC_0 = 0x00000336 +EMC_RAS_0 = 0x0000007C +EMC_RP_0 = 0x00000035 +EMC_R2W_0 = 0x00000032 +EMC_W2R_0 = 0x0000002F +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000035 +EMC_WR_RCD_0 = 0x00000035 +EMC_RRD_0 = 0x00000016 +EMC_REXT_0 = 0x0000001C +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x0000002A +EMC_QRST_0 = 0x00080002 +EMC_QSAFE_0 = 0x00000041 +EMC_RDV_0 = 0x00000043 +EMC_REFRESH_0 = 0x00002C6F +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001E +EMC_PDEX2RD_0 = 0x0000001E +EMC_PCHG2PDEN_0 = 0x00000006 +EMC_ACT2PDEN_0 = 0x0000002A +EMC_AR2PDEN_0 = 0x00000006 +EMC_RW2PDEN_0 = 0x00000041 +EMC_TXSR_0 = 0x0000034C +EMC_TCKE_0 = 0x00000018 +EMC_TFAW_0 = 0x00000058 +EMC_TRPAB_0 = 0x0000003E +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002CAF +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000055 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02DE002A +EMC_MRS_WAIT_CNT_0 = 0x07FF0038 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80123147 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000004 +EMC_CKE2PDEN_0 = 0x00000019 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000C +EMC_EINPUT_DURATION_0 = 0x0000002E +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002C +EMC_TPD_0 = 0x00000016 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1E190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000045 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000043 +EMC_RDV_EARLY_0 = 0x00000041 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862DE +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000043 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000B1B +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005826 +EMC_TXSRDLL_0 = 0x0000034C +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000035 +EMC_TR_RDV_MASK_0 = 0x00000045 +EMC_TR_QSAFE_0 = 0x00000041 +EMC_TR_QRST_0 = 0x00080002 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030F +EMC_IBDLY_0 = 0x10000020 +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000035 +EMC_QUSE_WIDTH_0 = 0x0000000C +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000019B +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000F0018 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x001A000C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230033 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000F0018 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x001A000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0004000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000F0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0004000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000F0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00260028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x0028002A +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x21222122 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x1F1B181F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000001F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x1C201C1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x1C20181B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000018 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x28272A29 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x23262817 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000025 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x101B1E1A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x1818120C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x1B201D21 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x1B201C1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000001F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x1D1C1C1D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1C1B1C1A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000001A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x2F2F302E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x2A2C272A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000027 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x2121191C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x1E1B1F17 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000001A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x040A090B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x06000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x090D070D +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x070B0008 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x090A0C10 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0A090A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00080D0A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x09080200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00080409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0307040A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x06000408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01040004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x07040604 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04040005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x09060108 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x09040603 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x25222426 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x22232023 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00180018 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000F000F +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x001A001A +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000018 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000818 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000405BB +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2966_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2966_emc.txt new file mode 100644 index 00000000..527849d9 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/2966_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000B2 +EMC_RFC_0 = 0x0000033F +EMC_RAS_0 = 0x0000007D +EMC_RP_0 = 0x00000036 +EMC_R2W_0 = 0x00000032 +EMC_W2R_0 = 0x0000002F +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000036 +EMC_WR_RCD_0 = 0x00000036 +EMC_RRD_0 = 0x00000017 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x0000002B +EMC_QRST_0 = 0x00080003 +EMC_QSAFE_0 = 0x00000041 +EMC_RDV_0 = 0x00000044 +EMC_REFRESH_0 = 0x00002CEF +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001F +EMC_PDEX2RD_0 = 0x0000001F +EMC_PCHG2PDEN_0 = 0x00000006 +EMC_ACT2PDEN_0 = 0x0000002A +EMC_AR2PDEN_0 = 0x00000006 +EMC_RW2PDEN_0 = 0x00000041 +EMC_TXSR_0 = 0x00000355 +EMC_TCKE_0 = 0x00000019 +EMC_TFAW_0 = 0x00000059 +EMC_TRPAB_0 = 0x0000003F +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002D2F +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000057 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02E6002A +EMC_MRS_WAIT_CNT_0 = 0x07FF0038 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012273D +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000004 +EMC_CKE2PDEN_0 = 0x0000001A +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000D +EMC_EINPUT_DURATION_0 = 0x0000002E +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002D +EMC_TPD_0 = 0x00000017 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03E9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000046 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000044 +EMC_RDV_EARLY_0 = 0x00000042 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862E6 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000044 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000B3B +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005921 +EMC_TXSRDLL_0 = 0x00000355 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000036 +EMC_TR_RDV_MASK_0 = 0x00000046 +EMC_TR_QSAFE_0 = 0x00000041 +EMC_TR_QRST_0 = 0x00080003 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E00309 +EMC_IBDLY_0 = 0x10000021 +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0F09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002B +EMC_QUSE_WIDTH_0 = 0x0000000C +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x000001A0 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000012 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC0200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000F0019 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x001A000C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230034 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000F0019 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x001A000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000F0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000F0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00260028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x0029002A +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00250027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x23232324 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x201C1A20 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000021 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x1E211E1D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x1C22191C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000001A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x2A292A2B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x24282A17 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000025 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x121D1F1D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x1B1A140E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000017 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x1B211E22 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x1C211D1D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000020 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x1E1C1D1E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1D1C1D1B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000001C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x3030322E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x2B2D272B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000029 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x23221B1D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x1F1C211A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000001C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x040A0A0A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x06000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x090E070E +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x070B0008 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x090A0C10 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0A090B00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000008 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00090D0A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x0A080200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00090509 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03070609 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03080B07 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x08030802 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x09040604 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x06040105 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x08050107 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x08030503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x24222327 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x22262925 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00190019 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000F000F +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x001A001A +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000019 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000818 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000405CB +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/3000_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/3000_emc.txt new file mode 100644 index 00000000..f790580f --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/3000_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000B4 +EMC_RFC_0 = 0x00000348 +EMC_RAS_0 = 0x0000007E +EMC_RP_0 = 0x00000036 +EMC_R2W_0 = 0x00000032 +EMC_W2R_0 = 0x0000002F +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000036 +EMC_WR_RCD_0 = 0x00000036 +EMC_RRD_0 = 0x00000017 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x0000002B +EMC_QRST_0 = 0x00080003 +EMC_QSAFE_0 = 0x00000041 +EMC_RDV_0 = 0x00000044 +EMC_REFRESH_0 = 0x00002D74 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000020 +EMC_PDEX2RD_0 = 0x00000020 +EMC_PCHG2PDEN_0 = 0x00000006 +EMC_ACT2PDEN_0 = 0x0000002A +EMC_AR2PDEN_0 = 0x00000006 +EMC_RW2PDEN_0 = 0x00000041 +EMC_TXSR_0 = 0x0000035F +EMC_TCKE_0 = 0x00000019 +EMC_TFAW_0 = 0x0000005A +EMC_TRPAB_0 = 0x0000003F +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002DB4 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000058 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02EE002A +EMC_MRS_WAIT_CNT_0 = 0x07FF0038 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80121A30 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000004 +EMC_CKE2PDEN_0 = 0x0000001A +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000D +EMC_EINPUT_DURATION_0 = 0x0000002E +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002D +EMC_TPD_0 = 0x00000017 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1E190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000046 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000044 +EMC_RDV_EARLY_0 = 0x00000042 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862EE +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000044 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000B5D +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005A23 +EMC_TXSRDLL_0 = 0x0000035F +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000036 +EMC_TR_RDV_MASK_0 = 0x00000046 +EMC_TR_QSAFE_0 = 0x00000041 +EMC_TR_QRST_0 = 0x00080003 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E00310 +EMC_IBDLY_0 = 0x10000021 +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C08 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000036 +EMC_QUSE_WIDTH_0 = 0x0000000C +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x000001A4 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000F0019 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x001A000C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230034 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000F0019 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x001A000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000F0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000F0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00250029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x0029002A +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x24252525 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x221C1A22 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000021 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x1F221F1F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x1D231A1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000001A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x2A2A2C2B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x25282B19 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000026 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x131F211E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x1B1B160F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000018 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x1C231F23 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x1E221E1E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000002E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x1F1D1D1F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1E1D1F1B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000002C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x3232332F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x2D2F2A2C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000002A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x24241C1E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x2D2B2E29 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000001C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x060A0A0B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x06010007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x090D070C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x060A0007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0A0A0D10 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x09080A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00090E0A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x0A080201 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02060409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x06000308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01040104 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x0A050605 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x07040105 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x04030103 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x08040503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x23202225 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x23272023 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00190019 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000F000F +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00060006 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x001A001A +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000019 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000818 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000405DC +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C08 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/3033_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/3033_emc.txt new file mode 100644 index 00000000..53d4d16e --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/3033_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000B6 +EMC_RFC_0 = 0x00000352 +EMC_RAS_0 = 0x0000007F +EMC_RP_0 = 0x00000037 +EMC_R2W_0 = 0x00000032 +EMC_W2R_0 = 0x00000030 +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000037 +EMC_WR_RCD_0 = 0x00000037 +EMC_RRD_0 = 0x00000017 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x0000002B +EMC_QRST_0 = 0x00080002 +EMC_QSAFE_0 = 0x00000042 +EMC_RDV_0 = 0x00000044 +EMC_REFRESH_0 = 0x00002DF5 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000020 +EMC_PDEX2RD_0 = 0x00000020 +EMC_PCHG2PDEN_0 = 0x00000006 +EMC_ACT2PDEN_0 = 0x0000002B +EMC_AR2PDEN_0 = 0x00000006 +EMC_RW2PDEN_0 = 0x00000041 +EMC_TXSR_0 = 0x00000368 +EMC_TCKE_0 = 0x00000019 +EMC_TFAW_0 = 0x0000005B +EMC_TRPAB_0 = 0x0000003F +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002E35 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000059 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02F7002B +EMC_MRS_WAIT_CNT_0 = 0x07FF0038 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80120D22 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000004 +EMC_CKE2PDEN_0 = 0x0000001A +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000C +EMC_EINPUT_DURATION_0 = 0x0000002F +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000018 +EMC_TPD_0 = 0x00000017 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1E190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000046 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000044 +EMC_RDV_EARLY_0 = 0x00000042 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862F7 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000044 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000B7D +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005B1E +EMC_TXSRDLL_0 = 0x00000368 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000036 +EMC_TR_RDV_MASK_0 = 0x00000046 +EMC_TR_QSAFE_0 = 0x00000042 +EMC_TR_QRST_0 = 0x00080002 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E00310 +EMC_IBDLY_0 = 0x10000021 +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000C +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0B08 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000036 +EMC_QUSE_WIDTH_0 = 0x0000000C +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x000001A9 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC0200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000F0019 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x001B000C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230034 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000F0019 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x001B000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000F0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000F0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00250028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x0028002A +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00230028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x25262627 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x231E1B23 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000022 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x20232020 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x1F241B1D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000001B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x2C2B2C2C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x27292C1A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000026 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x1B212120 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x1E1C1611 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000001B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x1E262125 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x20252020 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000024 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x211E1F21 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x201E201C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000001D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x33343531 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x2E302B2E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000002C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x25251D1F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x211E231B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000001D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0409090A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x05000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x090D070C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x060A0007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x090A0D10 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x04040400 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000008 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00090C09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x09060100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x0008040A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0307040A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x05000408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x00020001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x08040603 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04030005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x09070209 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x0A040705 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x22212226 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x21232023 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00190019 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000F000F +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x001B001B +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000019 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x0000080D +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040320 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000B08 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/3066_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/3066_emc.txt new file mode 100644 index 00000000..0f00b4c5 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/emc/3066_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000B7 +EMC_RFC_0 = 0x0000035B +EMC_RAS_0 = 0x0000007F +EMC_RP_0 = 0x00000038 +EMC_R2W_0 = 0x00000032 +EMC_W2R_0 = 0x00000030 +EMC_R2P_0 = 0x0000000E +EMC_W2P_0 = 0x00000033 +EMC_RD_RCD_0 = 0x00000038 +EMC_WR_RCD_0 = 0x00000038 +EMC_RRD_0 = 0x00000017 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000010 +EMC_QUSE_0 = 0x0000002B +EMC_QRST_0 = 0x00080002 +EMC_QSAFE_0 = 0x00000042 +EMC_RDV_0 = 0x00000044 +EMC_REFRESH_0 = 0x00002E75 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000020 +EMC_PDEX2RD_0 = 0x00000020 +EMC_PCHG2PDEN_0 = 0x00000006 +EMC_ACT2PDEN_0 = 0x0000002B +EMC_AR2PDEN_0 = 0x00000006 +EMC_RW2PDEN_0 = 0x00000041 +EMC_TXSR_0 = 0x00000372 +EMC_TCKE_0 = 0x00000019 +EMC_TFAW_0 = 0x0000005C +EMC_TRPAB_0 = 0x0000003F +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002EB5 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000005A +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02FF002B +EMC_MRS_WAIT_CNT_0 = 0x07FF0038 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80120C21 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000004 +EMC_CKE2PDEN_0 = 0x0000001B +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x88020036 +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000C +EMC_EINPUT_DURATION_0 = 0x0000002F +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002E +EMC_TPD_0 = 0x00000017 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1E190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000046 +EMC_WDV_MASK_0 = 0x00000010 +EMC_RDV_EARLY_MASK_0 = 0x00000044 +EMC_RDV_EARLY_0 = 0x00000042 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862FF +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000044 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000B9D +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005C19 +EMC_TXSRDLL_0 = 0x00000372 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000036 +EMC_TR_RDV_MASK_0 = 0x00000046 +EMC_TR_QSAFE_0 = 0x00000042 +EMC_TR_QRST_0 = 0x00080002 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E00309 +EMC_IBDLY_0 = 0x10000021 +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x0000000E +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0A09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000036 +EMC_QUSE_WIDTH_0 = 0x0000000C +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x000001AE +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x00100019 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x001B000C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230034 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x00100019 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x001B000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000F0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000F0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00250028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x0029002A +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00200027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x24242424 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x231D1B23 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000002D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x1F211F1F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x1F24191D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000001A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x27272C2A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x25262A19 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000025 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x131E1F1E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x1D1B150F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x20252224 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x20242022 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000002F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x2D2C2D2D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1D1D1F1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000002C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x3031322E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x2B2D2A2B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000027 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x25251C1D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x221D2419 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000001D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x060B0B0B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x07000008 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x090D060D +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x060B0008 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0B0A0C10 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0B0A0A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000009 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00080D0A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x0A080300 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x0008050B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0306040B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x05000307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x00010001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05050503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04020005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x08070307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x08050604 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x25232526 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x22241F24 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00190019 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x00080008 +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x001B001B +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000019 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000819 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000405FD +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000A09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/1866_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/1866_mc.txt new file mode 100644 index 00000000..380b6f1c --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/1866_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD3B +MC_SMMU_PTC_FLUSH_0 = 0x77D584D1 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0000000E +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80010080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000007 +MC_EMEM_ARB_TIMING_RP_0 = 0x00000008 +MC_EMEM_ARB_TIMING_RC_0 = 0x0000001C +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000012 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000012 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x000F0A0E +MC_EMEM_ARB_MISC0_0 = 0x726E2A1D +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80020080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02130810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000041 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x000000F2 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x00000335 +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001B +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x00001501 +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x006D0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x006D0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x006D0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x006D0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x006D006D +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x006D0019 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x006D0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x006D0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x006D0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x006D003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00800019 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000006D +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x006D0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x006D0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000006D +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080013 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x006D0016 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x006D0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x006D0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2133_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2133_mc.txt new file mode 100644 index 00000000..e8b5f29a --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2133_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCDB +MC_SMMU_PTC_FLUSH_0 = 0x77E6E341 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000010 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000008 +MC_EMEM_ARB_TIMING_RP_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RC_0 = 0x00000020 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000015 +MC_EMEM_ARB_TIMING_FAW_0 = 0x0000000F +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000003 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00100B10 +MC_EMEM_ARB_MISC0_0 = 0x72703021 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C1D1020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80020080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x0A130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000004A +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00600004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00600038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00600005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00600014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00600060 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00600016 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00600095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00600041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00600080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0060003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00600013 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000060 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00600090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00600004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000060 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080011 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00600013 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00600005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00600018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2166_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2166_mc.txt new file mode 100644 index 00000000..cf7143f2 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2166_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD3B +MC_SMMU_PTC_FLUSH_0 = 0x77E7F4D1 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000010 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000008 +MC_EMEM_ARB_TIMING_RP_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RC_0 = 0x00000020 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000015 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000010 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00100B10 +MC_EMEM_ARB_MISC0_0 = 0x72713121 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630B0 +MC_ERR_SEC_ADR_0 = 0x08130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000004B +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x005E0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x005E0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x005E0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x005E0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x005E005E +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x005E0015 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x005E0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x005E0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x005E0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x005E003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x005E0013 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000005E +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x005E0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x005E0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000005E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080010 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x005E0013 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x005E0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x005E0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2200_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2200_mc.txt new file mode 100644 index 00000000..476dffd0 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2200_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCDB +MC_SMMU_PTC_FLUSH_0 = 0x77E63341 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x08000010 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80030080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000008 +MC_EMEM_ARB_TIMING_RP_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RC_0 = 0x00000021 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000016 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000010 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00110B10 +MC_EMEM_ARB_MISC0_0 = 0x72713222 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C1D1020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02130000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000004C +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x005D0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x005D0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x005D0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x005D0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x005D005D +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x005D0015 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x005D0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x005D0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x005D0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x005D003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x005D0012 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000005D +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x005D0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x005D0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000005D +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080010 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x005D0012 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x005D0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x005D0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2233_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2233_mc.txt new file mode 100644 index 00000000..143af93e --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2233_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x01010200 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCDB +MC_SMMU_PTC_FLUSH_0 = 0x77E85341 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000010 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000021 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000016 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000010 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00110B10 +MC_EMEM_ARB_MISC0_0 = 0x72713322 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C1D1000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630B0 +MC_ERR_SEC_ADR_0 = 0x02130810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000004E +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x005B0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x005B0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x005B0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x005B0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x005B005B +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x005B0015 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x005B0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x005B0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x005B0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x005B003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x005B0012 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000005B +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x005B0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x005B0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000005B +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080010 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x005B0012 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x005B0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x005B0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2266_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2266_mc.txt new file mode 100644 index 00000000..1109fb00 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2266_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x79FBF7A0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD5B +MC_SMMU_PTC_FLUSH_0 = 0x77E77541 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000011 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000022 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000016 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000010 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00110B11 +MC_EMEM_ARB_MISC0_0 = 0x72713323 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C1D1020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80050080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x00001060 +MC_ERR_SEC_ADR_0 = 0x02002000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000037 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x005A0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x005A0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x005A0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x005A0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x005A005A +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x005A0014 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x005A0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x005A0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x005A0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x005A003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x005A0012 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000005A +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x005A0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x005A0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000005A +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080010 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x005A0012 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x005A0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00800018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2300_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2300_mc.txt new file mode 100644 index 00000000..dad201f1 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2300_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x68372880 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFBDB +MC_SMMU_PTC_FLUSH_0 = 0x456B4F41 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000011 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000022 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000017 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000011 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000B +MC_EMEM_ARB_DA_TURNS_0 = 0x05060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00110C11 +MC_EMEM_ARB_MISC0_0 = 0x72723423 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C1D1000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630B0 +MC_ERR_SEC_ADR_0 = 0x02130810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000050 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00590004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00590038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00590005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00590014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00590059 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00590014 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00590095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00590041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00590080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0059003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00590012 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000059 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00590090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00590004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000059 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000F +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00590012 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00590005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00590018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2333_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2333_mc.txt new file mode 100644 index 00000000..96715058 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2333_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD4B +MC_SMMU_PTC_FLUSH_0 = 0x7ABA9521 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x08000011 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000022 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000017 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000011 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00110C11 +MC_EMEM_ARB_MISC0_0 = 0x72723523 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02130810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000051 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00570004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00570038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00570005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00570014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00570057 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00570014 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00570095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00570041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00570080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0057003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00570011 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000057 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00570090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00570004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000057 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000F +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00570011 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00570005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00570018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2366_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2366_mc.txt new file mode 100644 index 00000000..dd557466 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2366_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFC5B +MC_SMMU_PTC_FLUSH_0 = 0x77E06141 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000011 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000023 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000017 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000011 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00110C11 +MC_EMEM_ARB_MISC0_0 = 0x72723624 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000010E0 +MC_ERR_SEC_ADR_0 = 0x02121000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000052 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00560004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00560038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00560005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00560014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00560056 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00560013 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00560095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00560041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00560080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0056003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00560011 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000056 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00560090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00560004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000056 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000F +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00560011 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00560005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00560018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2400_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2400_mc.txt new file mode 100644 index 00000000..926da7e2 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2400_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x01211200 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCDB +MC_SMMU_PTC_FLUSH_0 = 0x77E3D341 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000012 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000024 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000018 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000011 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00120C12 +MC_EMEM_ARB_MISC0_0 = 0x72723625 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000400C0 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000053 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00550004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00550038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00550005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00550014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00550055 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00550013 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00550095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00550041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00550080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0055003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00550011 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000055 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00550090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00550004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000055 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000F +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00550011 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00550005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00550018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2433_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2433_mc.txt new file mode 100644 index 00000000..e1bf8eef --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2433_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x01211200 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCDB +MC_SMMU_PTC_FLUSH_0 = 0x77CE0341 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000012 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000024 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000018 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000012 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00120C12 +MC_EMEM_ARB_MISC0_0 = 0x72733725 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000230F0 +MC_ERR_SEC_ADR_0 = 0x02130810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000055 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00540004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00540038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00540005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00540014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00540054 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00540013 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00540095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00540041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00540080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0054003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00540011 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000054 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00540090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00540004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000054 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000F +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00540011 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00540005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00540018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2466_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2466_mc.txt new file mode 100644 index 00000000..da292d45 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2466_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCDB +MC_SMMU_PTC_FLUSH_0 = 0x77E38341 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x08000012 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80030080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000025 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000018 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000012 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000D +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06060000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00120C12 +MC_EMEM_ARB_MISC0_0 = 0x72733826 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000400C0 +MC_ERR_VPR_ADR_0 = 0x0C1D1000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000056 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00530004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00530038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00530005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00530014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00530053 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00530013 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00800095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00530041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00530080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0053003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00530010 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000053 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00530090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00530004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000053 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000E +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00530010 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00530005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00530018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2500_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2500_mc.txt new file mode 100644 index 00000000..169ba668 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2500_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCDB +MC_SMMU_PTC_FLUSH_0 = 0x77E3A341 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000012 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80100080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000025 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000019 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000012 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00120C12 +MC_EMEM_ARB_MISC0_0 = 0x72733926 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80030080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02930800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000057 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00510004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00510038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00510005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00510014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00510051 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00510012 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00510095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00510041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00510080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0051003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00510010 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000051 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00510090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00510004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000051 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000E +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00510010 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00510005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00510018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2533_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2533_mc.txt new file mode 100644 index 00000000..77889d15 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2533_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x01211200 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCDB +MC_SMMU_PTC_FLUSH_0 = 0x7878C351 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000013 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000026 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000019 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000012 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00120D13 +MC_EMEM_ARB_MISC0_0 = 0x72733927 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000020C1 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000230F0 +MC_ERR_SEC_ADR_0 = 0x02130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000058 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00500004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00500038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00500005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00500014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00500050 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00500012 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00500095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00500041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00500080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0050003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00500010 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000050 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00500090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00500004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000050 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000E +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00500010 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00500005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00500018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2566_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2566_mc.txt new file mode 100644 index 00000000..ddb05b12 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2566_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000F839B +MC_SMMU_PTC_FLUSH_0 = 0x3596FE41 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000013 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80090080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000026 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000019 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000013 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00120D13 +MC_EMEM_ARB_MISC0_0 = 0x72743A27 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x00000040 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x00063070 +MC_ERR_SEC_ADR_0 = 0x0A130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000059 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x004F0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x004F0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x004F0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x004F0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x004F004F +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x004F0012 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x004F0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x004F0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x004F0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x004F003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x004F0010 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000004F +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x004F0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x004F0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000004F +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000E +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x004F0010 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x004F0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x004F0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2600_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2600_mc.txt new file mode 100644 index 00000000..1845c033 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2600_mc.txt @@ -0,0 +1,56 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +mc_emem_arb_cfg = 0x08000013 +mc_emem_arb_outstanding_req = 0x80040080 +mc_emem_arb_timing_rcd = 0x0000000A +mc_emem_arb_timing_rp = 0x0000000B +mc_emem_arb_timing_rc = 0x00000027 +mc_emem_arb_timing_ras = 0x0000001A +mc_emem_arb_timing_faw = 0x00000013 +mc_emem_arb_timing_rrd = 0x00000004 +mc_emem_arb_timing_rap2pre = 0x00000004 +mc_emem_arb_timing_wap2pre = 0x0000000F +mc_emem_arb_timing_r2r = 0x00000001 +mc_emem_arb_timing_w2w = 0x00000001 +mc_emem_arb_timing_r2w = 0x0000000E +mc_emem_arb_timing_w2r = 0x0000000C +mc_emem_arb_da_turns = 0x06070000 +mc_emem_arb_da_covers = 0x00120D13 +mc_emem_arb_misc0 = 0x72743B28 +mc_emem_arb_misc1 = 0x70000F0F +mc_emem_arb_misc2 = 0x00000000 +mc_emem_arb_ring1_throttle = 0x001F0000 +mc_emem_arb_timing_rfcpb = 0x0000005A +mc_emem_arb_timing_ccdmw = 0x00000008 +mc_emem_arb_dhyst_ctrl = 0x000A1020 +mc_emem_arb_dhyst_timeout_util_0 = 0x0000001A +mc_emem_arb_dhyst_timeout_util_1 = 0x0000001A +mc_emem_arb_dhyst_timeout_util_2 = 0x0000001A +mc_emem_arb_dhyst_timeout_util_3 = 0x0000001A +mc_emem_arb_dhyst_timeout_util_4 = 0x0000001A +mc_emem_arb_dhyst_timeout_util_5 = 0x0000001A +mc_emem_arb_dhyst_timeout_util_6 = 0x0000001A +mc_emem_arb_dhyst_timeout_util_7 = 0x0000001A +mc_mll_mpcorer_ptsa_rate = 0x00000115 +mc_ftop_ptsa_rate = 0x00000000 +mc_ptsa_grant_decrement = 0x000017FF +mc_latency_allowance_avpc_0 = 0x004E0004 +mc_latency_allowance_sdmmcaa_0 = 0x004E0005 +mc_latency_allowance_sdmmca_0 = 0x004E0014 +mc_latency_allowance_isp2_0 = 0x0000002C +mc_latency_allowance_isp2_1 = 0x004E004E +mc_latency_allowance_vic_0 = 0x004E0012 +mc_latency_allowance_nvdec_0 = 0x004E0095 +mc_latency_allowance_tsec_0 = 0x004E0041 +mc_latency_allowance_ppcs_1 = 0x004E0080 +mc_latency_allowance_xusb_0 = 0x004E003D +mc_latency_allowance_ppcs_0 = 0x00340049 +mc_latency_allowance_gpu2_0 = 0x004E0010 +mc_latency_allowance_hc_1 = 0x0000004E +mc_latency_allowance_sdmmc_0 = 0x004E0090 +mc_latency_allowance_mpcore_0 = 0x004E0004 +mc_latency_allowance_vi2_0 = 0x0000004E +mc_latency_allowance_hc_0 = 0x0008000E +mc_latency_allowance_gpu_0 = 0x004E0010 +mc_latency_allowance_sdmmcab_0 = 0x004E0005 +mc_latency_allowance_nvenc_0 = 0x004E0018 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2633_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2633_mc.txt new file mode 100644 index 00000000..125b79f5 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2633_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x01211200 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCDB +MC_SMMU_PTC_FLUSH_0 = 0x77E3F341 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000013 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000027 +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001A +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000013 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00130D13 +MC_EMEM_ARB_MISC0_0 = 0x72743C28 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630B0 +MC_ERR_SEC_ADR_0 = 0x0A130810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000005C +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000363 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000D +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x004D0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x004D0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x004D0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x004D0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x004D004D +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x004D0011 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x004D0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x004D0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x004D0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x004D003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x004D000F +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000004D +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x004D0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x004D0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000004D +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000D +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x004D000F +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x004D0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x004D0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2666_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2666_mc.txt new file mode 100644 index 00000000..ff8f88b5 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2666_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCBB +MC_SMMU_PTC_FLUSH_0 = 0x77E372C1 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000014 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80010080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000027 +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001A +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000013 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00130D13 +MC_EMEM_ARB_MISC0_0 = 0x72743C28 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C1D1020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80020080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x00001060 +MC_ERR_SEC_ADR_0 = 0x02022000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000005D +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000363 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000D +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x004C0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x004C0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x004C0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x004C0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x004C004C +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x004C0011 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x004C0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x004C0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x004C0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x004C003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x004C000F +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000004C +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x004C0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x004C0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000004C +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000D +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x004C000F +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x004C0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x004C0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2700_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2700_mc.txt new file mode 100644 index 00000000..f9af55b0 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2700_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x01010200 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFB9B +MC_SMMU_PTC_FLUSH_0 = 0x104AEE61 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000014 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80010080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RC_0 = 0x00000028 +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001B +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000014 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00130D14 +MC_EMEM_ARB_MISC0_0 = 0x72753D29 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000020C0 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x00063090 +MC_ERR_SEC_ADR_0 = 0x0A130810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000005E +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000362 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x004B0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00800038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x004B0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00800014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x004B004B +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x0080001D +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x004B0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x004B0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x004B0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x004B003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x004B000F +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000080 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x004B0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x004B0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000004B +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000D +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x004B000F +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x004B0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x004B0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2733_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2733_mc.txt new file mode 100644 index 00000000..20d13bcd --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2733_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFC9B +MC_SMMU_PTC_FLUSH_0 = 0x77C89261 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x08000014 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RC_0 = 0x00000029 +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001B +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000014 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00130E14 +MC_EMEM_ARB_MISC0_0 = 0x72753E2A +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630B0 +MC_ERR_SEC_ADR_0 = 0x0A130810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000005F +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000362 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x004A0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x004A0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x004A0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x004A0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x004A004A +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x004A0011 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x004A0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x004A0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x004A0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x004A003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x004A000F +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000004A +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x004A0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x004A0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000004A +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000D +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x004A000F +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x004A0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x004A0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2766_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2766_mc.txt new file mode 100644 index 00000000..12ed1656 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2766_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD8B +MC_SMMU_PTC_FLUSH_0 = 0x77E71611 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000014 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RC_0 = 0x00000029 +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001C +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000014 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00130E14 +MC_EMEM_ARB_MISC0_0 = 0x72753F2A +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x001E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x003E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80090080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630B0 +MC_ERR_SEC_ADR_0 = 0x0A130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000060 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000362 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x004A0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x004A0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x004A0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x004A0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x004A004A +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x004A0011 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x004A0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x004A0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x004A0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x004A003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x004A000F +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000004A +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x004A0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x004A0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000004A +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000D +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x004A000F +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x004A0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x004A0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2800_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2800_mc.txt new file mode 100644 index 00000000..ec3ebb2a --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2800_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x11010200 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCAB +MC_SMMU_PTC_FLUSH_0 = 0x77E8C291 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000015 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80080080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002A +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001C +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000014 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000D +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000C +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x000D080C +MC_EMEM_ARB_MISC0_0 = 0x72753F2B +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000020C0 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80050080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000230B0 +MC_ERR_SEC_ADR_0 = 0x08130850 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000061 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000363 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x00000DB7 +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00490038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00490005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00490014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00490049 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00490010 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00490095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00490041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00490080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0049003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0049000E +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000049 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00490090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00490004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000049 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000D +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0049000E +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00490005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00490018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2833_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2833_mc.txt new file mode 100644 index 00000000..ec06a0d1 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2833_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFC8B +MC_SMMU_PTC_FLUSH_0 = 0x77E64231 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000015 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002A +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001C +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000015 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00130E15 +MC_EMEM_ARB_MISC0_0 = 0x7276402B +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x001E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x003E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000400C0 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80020080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x0A110800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000063 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000363 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00480004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00480038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00480005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00480014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00480048 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00480010 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00480095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00480041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00480080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0048003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0048000E +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000048 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00480090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00480004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000048 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000C +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0048000E +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00480005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00480018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2866_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2866_mc.txt new file mode 100644 index 00000000..22a91556 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2866_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCBB +MC_SMMU_PTC_FLUSH_0 = 0x787982C1 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x08000015 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80010080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002B +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001D +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000015 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00140E15 +MC_EMEM_ARB_MISC0_0 = 0x7276412C +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C1D1000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80020080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000620F0 +MC_ERR_SEC_ADR_0 = 0x02130000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000064 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000363 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00470004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00470038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00470005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00470014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00470047 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00470010 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00470095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00470041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00470080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0047003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0047000E +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000047 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00470090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00470004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000047 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000C +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0047000E +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00470005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00470018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2900_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2900_mc.txt new file mode 100644 index 00000000..92ef06c6 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2900_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD5B +MC_SMMU_PTC_FLUSH_0 = 0x77E64541 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000015 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000D +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002B +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001D +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000015 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00140E15 +MC_EMEM_ARB_MISC0_0 = 0x7276422C +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80020080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630B0 +MC_ERR_SEC_ADR_0 = 0x0A930850 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000065 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000363 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00460004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00460038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00460005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00460014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00460046 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00460010 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00460095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00460041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00460080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0046003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0046000E +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000046 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00460090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00460004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000046 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000C +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0046000E +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00460005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00460018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2933_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2933_mc.txt new file mode 100644 index 00000000..01e9fa51 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2933_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0xF3010780 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFC1B +MC_SMMU_PTC_FLUSH_0 = 0x77E6EAE1 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000016 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000D +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002C +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001D +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000015 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00140E16 +MC_EMEM_ARB_MISC0_0 = 0x7276422D +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C111020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02130000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000066 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000363 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00450004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00450038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00450005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00450014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00450045 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00450010 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00450095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00450041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00450080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0045003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0045000E +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000045 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00450090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00450004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000045 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000C +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0045000E +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00450005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00450018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2966_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2966_mc.txt new file mode 100644 index 00000000..d98dc751 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/2966_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0xF300A680 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCFB +MC_SMMU_PTC_FLUSH_0 = 0x77E623F1 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000016 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80030080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000D +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002C +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001E +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000016 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00140F16 +MC_EMEM_ARB_MISC0_0 = 0x7257432D +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C1D1020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80040080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x0A130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000067 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000362 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x00000011 +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000B +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00450004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00450038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00450005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00450014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00450045 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00450010 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00450095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00450041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00450080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0045003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0045000E +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000045 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00450090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00450004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000045 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000C +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0045000E +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00800005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00450018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/3000_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/3000_mc.txt new file mode 100644 index 00000000..34ddbf9d --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/3000_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCDB +MC_SMMU_PTC_FLUSH_0 = 0x77E7C341 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x08000016 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000D +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002C +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001E +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000016 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00140F16 +MC_EMEM_ARB_MISC0_0 = 0x7277442D +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C1D1020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x00001060 +MC_ERR_SEC_ADR_0 = 0x0A511000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000068 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000362 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000B +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00440004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00440038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00440005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00440014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00440044 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x0044000F +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00990095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00440041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00440080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0044003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0044000D +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000044 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00440090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00440004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000044 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000C +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0044000D +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00440005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00440018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/3033_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/3033_mc.txt new file mode 100644 index 00000000..fce7765e --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/3033_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD1B +MC_SMMU_PTC_FLUSH_0 = 0x77DC7451 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000016 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000D +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002D +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001E +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000016 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00140F16 +MC_EMEM_ARB_MISC0_0 = 0x7277452E +C_EMEM_ARB_MISC1_0 = 0x70000F0E +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C1914A0 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x801C0080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000410A0 +MC_ERR_SEC_ADR_0 = 0x0A130810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000006A +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000362 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000B +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00430004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00430038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00430005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00430014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00430043 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x0043000F +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00430095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00430041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00430080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0043003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0043000D +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000080 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00430090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00430004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000043 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000C +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0043000D +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00430005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00430018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/3066_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/3066_mc.txt new file mode 100644 index 00000000..4208f569 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/1866/mc/3066_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x4AC01800 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFC5B +MC_SMMU_PTC_FLUSH_0 = 0x77E3D141 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000017 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80090080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000D +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002D +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001E +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000016 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000F +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00150F16 +MC_EMEM_ARB_MISC0_0 = 0x7277452E +C_EMEM_ARB_MISC1_0 = 0x70000F0E +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000230B0 +MC_ERR_SEC_ADR_0 = 0x08130810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000006B +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000362 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000B +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00420004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00420038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00420005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00420014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00420042 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x0042000F +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00420095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00420041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00420080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0042003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0042000D +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000042 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00420090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00420004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000042 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000C +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0042000D +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00990005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00420018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2133_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2133_emc.txt new file mode 100644 index 00000000..3ca3344d --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2133_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000080 +EMC_RFC_0 = 0x00000256 +EMC_RAS_0 = 0x0000005A +EMC_RP_0 = 0x00000027 +EMC_R2W_0 = 0x00000031 +EMC_W2R_0 = 0x0000002B +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000027 +EMC_WR_RCD_0 = 0x00000027 +EMC_RRD_0 = 0x00000010 +EMC_REXT_0 = 0x0000001A +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002C +EMC_QRST_0 = 0x0007000D +EMC_QSAFE_0 = 0x0000003D +EMC_RDV_0 = 0x00000043 +EMC_REFRESH_0 = 0x0000203F +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000016 +EMC_PDEX2RD_0 = 0x00000016 +EMC_PCHG2PDEN_0 = 0x00000004 +EMC_ACT2PDEN_0 = 0x0000001E +EMC_AR2PDEN_0 = 0x00000004 +EMC_RW2PDEN_0 = 0x00000047 +EMC_TXSR_0 = 0x00000266 +EMC_TCKE_0 = 0x00000012 +EMC_TFAW_0 = 0x00000040 +EMC_TRPAB_0 = 0x0000002D +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001A +EMC_TREFBW_0 = 0x0000207F +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000003F +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x0216001E +EMC_MRS_WAIT_CNT_0 = 0x07FF0039 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012CBE9 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000013 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000016 +EMC_EINPUT_DURATION_0 = 0x00000024 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000020 +EMC_TPD_0 = 0x00000010 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D180000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000045 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000043 +EMC_RDV_EARLY_0 = 0x00000041 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186216 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000043 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F070A +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x0000080F +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004062 +EMC_TXSRDLL_0 = 0x00000266 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000035 +EMC_TR_RDV_MASK_0 = 0x00000045 +EMC_TR_QSAFE_0 = 0x0000003D +EMC_TR_QRST_0 = 0x0007000D +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030B +EMC_IBDLY_0 = 0x10000023 +EMC_OBDLY_0 = 0x10000006 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0A0B +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000035 +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000012B +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x88204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x00210029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000A0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000A0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00240026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00200024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00210024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x3E3F3F40 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x3D39383C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000003C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x3A3C3938 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x383C3438 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000035 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x43424343 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x3F414236 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000040 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x323A3B39 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x3837332F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000035 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x393D3B3D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x3A3D393B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000003C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x3A39393A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x3A393A37 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000039 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x08080907 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04070204 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x3D3D3839 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x3B393C36 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000038 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04080707 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x05010005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x06090309 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03070004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0708090B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x08080900 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x01060907 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07060100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070406 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02050507 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03010304 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01020001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05040503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x04040004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x03010100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x28262627 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x28252729 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00120012 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x0000000B +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000812 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004042B +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2166_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2166_emc.txt new file mode 100644 index 00000000..40e543b7 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2166_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000082 +EMC_RFC_0 = 0x0000025F +EMC_RAS_0 = 0x0000005B +EMC_RP_0 = 0x00000027 +EMC_R2W_0 = 0x00000031 +EMC_W2R_0 = 0x0000002B +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000027 +EMC_WR_RCD_0 = 0x00000027 +EMC_RRD_0 = 0x00000011 +EMC_REXT_0 = 0x00000019 +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002D +EMC_QRST_0 = 0x0007000E +EMC_QSAFE_0 = 0x0000003E +EMC_RDV_0 = 0x00000044 +EMC_REFRESH_0 = 0x000020BF +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000017 +EMC_PDEX2RD_0 = 0x00000017 +EMC_PCHG2PDEN_0 = 0x00000004 +EMC_ACT2PDEN_0 = 0x0000001F +EMC_AR2PDEN_0 = 0x00000004 +EMC_RW2PDEN_0 = 0x00000047 +EMC_TXSR_0 = 0x0000026F +EMC_TCKE_0 = 0x00000013 +EMC_TFAW_0 = 0x00000041 +EMC_TRPAB_0 = 0x0000002E +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001A +EMC_TREFBW_0 = 0x000020FF +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000040 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x021E001F +EMC_MRS_WAIT_CNT_0 = 0x07FF0039 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80040101 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000013 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000017 +EMC_EINPUT_DURATION_0 = 0x00000024 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000021 +EMC_TPD_0 = 0x00000011 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D180000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x00110835 +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000046 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000044 +EMC_RDV_EARLY_0 = 0x00000042 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x0118621E +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000044 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x0000082F +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000415D +EMC_TXSRDLL_0 = 0x0000026F +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000036 +EMC_TR_RDV_MASK_0 = 0x00000046 +EMC_TR_QSAFE_0 = 0x0000003E +EMC_TR_QRST_0 = 0x0007000E +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030B +EMC_IBDLY_0 = 0x10000024 +EMC_OBDLY_0 = 0x10000006 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000036 +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000130 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A01A010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x88200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x00210029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000B0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x00060000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00200024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x3F404141 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x3F3B393D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000003F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x3B3E3B3A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x3A3E3639 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000037 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x44434444 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x41434437 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000041 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x333B3C3B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x3A393430 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000037 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x3A3F3D3F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x3B3F3B3C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000003E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x3B3A3A3B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x3B3A3B38 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000003A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x090A0B08 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x06080406 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x3F3F393C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x3D3B3E38 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000003A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03070707 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x03010005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04080308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02050003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x07080A0B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07080800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x01060908 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06060100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070406 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02050407 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03010204 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05040402 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x05050104 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x05020200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x28242628 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x28262628 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00120012 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x00080008 +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000012 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000812 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004043B +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2200_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2200_emc.txt new file mode 100644 index 00000000..61f78b67 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2200_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000084 +EMC_RFC_0 = 0x00000268 +EMC_RAS_0 = 0x0000005D +EMC_RP_0 = 0x00000028 +EMC_R2W_0 = 0x00000031 +EMC_W2R_0 = 0x0000002B +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000028 +EMC_WR_RCD_0 = 0x0000001D +EMC_RRD_0 = 0x00000011 +EMC_REXT_0 = 0x00000019 +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002D +EMC_QRST_0 = 0x0007000E +EMC_QSAFE_0 = 0x0000003E +EMC_RDV_0 = 0x00000044 +EMC_REFRESH_0 = 0x00002144 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000017 +EMC_PDEX2RD_0 = 0x00000017 +EMC_PCHG2PDEN_0 = 0x00000004 +EMC_ACT2PDEN_0 = 0x0000001F +EMC_AR2PDEN_0 = 0x00000004 +EMC_RW2PDEN_0 = 0x00000047 +EMC_TXSR_0 = 0x00000279 +EMC_TCKE_0 = 0x00000013 +EMC_TFAW_0 = 0x00000042 +EMC_TRPAB_0 = 0x0000002F +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001A +EMC_TREFBW_0 = 0x00002184 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000041 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x0226001F +EMC_MRS_WAIT_CNT_0 = 0x07FF0039 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80129CB9 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000013 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000017 +EMC_EINPUT_DURATION_0 = 0x00000024 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000021 +EMC_TPD_0 = 0x00000011 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D180000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430021 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000046 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000044 +EMC_RDV_EARLY_0 = 0x00000042 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186226 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000044 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000851 +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000425F +EMC_TXSRDLL_0 = 0x00000279 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000036 +EMC_TR_RDV_MASK_0 = 0x00000046 +EMC_TR_QSAFE_0 = 0x0000003E +EMC_TR_QRST_0 = 0x0007000E +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x10000024 +EMC_OBDLY_0 = 0x10000006 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000036 +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000134 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x88204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0021002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00130009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000B0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000B0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x40414242 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x403C3A3F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000003F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x3D3F3D3C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x3C41373B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000039 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x46444747 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x42454638 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000044 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x343D3E3C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x3B3A3532 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000038 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x3C413E40 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x3E413D3E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000040 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x3C3B3C3C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x3D3C3C39 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000003B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x0B0B0C09 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x08090508 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x40403B3C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x3E3D3F39 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000003B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04070707 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x03090309 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02070004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0707090A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x08080800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00060908 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07050101 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00060306 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02050307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03030505 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x04030303 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05030302 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x02010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x05040104 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x03020200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x26252929 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x27272826 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00120012 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000012 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x070A070A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000812 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004044C +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2233_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2233_emc.txt new file mode 100644 index 00000000..2d65f0e9 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2233_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000086 +EMC_RFC_0 = 0x00000272 +EMC_RAS_0 = 0x0000005E +EMC_RP_0 = 0x00000029 +EMC_R2W_0 = 0x00000031 +EMC_W2R_0 = 0x0000002B +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000029 +EMC_WR_RCD_0 = 0x00000029 +EMC_RRD_0 = 0x00000011 +EMC_REXT_0 = 0x00000019 +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002D +EMC_QRST_0 = 0x0007000D +EMC_QSAFE_0 = 0x0000003E +EMC_RDV_0 = 0x00000044 +EMC_REFRESH_0 = 0x000021C5 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000017 +EMC_PDEX2RD_0 = 0x00000017 +EMC_PCHG2PDEN_0 = 0x00000004 +EMC_ACT2PDEN_0 = 0x00000020 +EMC_AR2PDEN_0 = 0x00000004 +EMC_RW2PDEN_0 = 0x00000048 +EMC_TXSR_0 = 0x00000282 +EMC_TCKE_0 = 0x00000013 +EMC_TFAW_0 = 0x00000043 +EMC_TRPAB_0 = 0x0000002F +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001A +EMC_TREFBW_0 = 0x00002205 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000042 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x022F0020 +EMC_MRS_WAIT_CNT_0 = 0x07FF0039 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012809D +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000013 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000016 +EMC_EINPUT_DURATION_0 = 0x00000025 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000022 +EMC_TPD_0 = 0x00000011 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430021 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000046 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000044 +EMC_RDV_EARLY_0 = 0x00000042 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x0118622F +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000044 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000871 +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000435A +EMC_TXSRDLL_0 = 0x00000282 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000036 +EMC_TR_RDV_MASK_0 = 0x00000046 +EMC_TR_QSAFE_0 = 0x0000003E +EMC_TR_QRST_0 = 0x0007000D +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x10000024 +EMC_OBDLY_0 = 0x10000006 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0E09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000036 +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000139 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xCC200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002F +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000B0012 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000B0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000B0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210023 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x42424444 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x413D3B40 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000041 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x3F413E3E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x3D423A3D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000003A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x48474949 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x4548483A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000046 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x363F3F3E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x3C3B3733 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000039 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x3E424042 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x3E433F3F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000041 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x3E3C3D3F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x3E3E3E3B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000003C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x0D0E0F0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x0A0C0809 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x41423C3E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x403E413B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000003C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04080806 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04090407 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02050003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0707090B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07080800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050908 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07060100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00050207 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02040207 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03010305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05030302 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03010001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x04040105 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x05020301 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x2726252A +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x27282625 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00120012 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000012 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000812 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004045D +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000E09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2266_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2266_emc.txt new file mode 100644 index 00000000..609f8e6e --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2266_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000088 +EMC_RFC_0 = 0x0000027B +EMC_RAS_0 = 0x00000060 +EMC_RP_0 = 0x00000029 +EMC_R2W_0 = 0x00000031 +EMC_W2R_0 = 0x0000002B +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000029 +EMC_WR_RCD_0 = 0x00000029 +EMC_RRD_0 = 0x00000011 +EMC_REXT_0 = 0x0000001A +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002D +EMC_QRST_0 = 0x0007000D +EMC_QSAFE_0 = 0x0000003E +EMC_RDV_0 = 0x00000044 +EMC_REFRESH_0 = 0x00002245 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000017 +EMC_PDEX2RD_0 = 0x00000017 +EMC_PCHG2PDEN_0 = 0x00000004 +EMC_ACT2PDEN_0 = 0x00000020 +EMC_AR2PDEN_0 = 0x00000004 +EMC_RW2PDEN_0 = 0x00000048 +EMC_TXSR_0 = 0x0000028C +EMC_TCKE_0 = 0x00000013 +EMC_TFAW_0 = 0x00000044 +EMC_TRPAB_0 = 0x00000030 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001B +EMC_TREFBW_0 = 0x00002285 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000042 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02370020 +EMC_MRS_WAIT_CNT_0 = 0x07FF0039 +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80126E8A +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000002 +EMC_CKE2PDEN_0 = 0x00000014 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000016 +EMC_EINPUT_DURATION_0 = 0x00000025 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000022 +EMC_TPD_0 = 0x00000011 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D180000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000046 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000044 +EMC_RDV_EARLY_0 = 0x00000042 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186237 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000044 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000891 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004455 +EMC_TXSRDLL_0 = 0x0000028C +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000036 +EMC_TR_RDV_MASK_0 = 0x00000046 +EMC_TR_QSAFE_0 = 0x0000003E +EMC_TR_QRST_0 = 0x0007000D +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x10000024 +EMC_OBDLY_0 = 0x10000006 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000036 +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000013E +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000B0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002F +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000B0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x00060000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000B0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x43444545 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x433F3D42 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000042 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x40423F3F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x3F433B3E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000003B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x49494A4A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x46494A3C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000047 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x3740413F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x3E3C3834 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000003A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x3F444144 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x41444040 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000042 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x3F3E3F3F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x403F3F3C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000003E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x0E0E100D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x0B0D090B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x43433E3F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x4140433C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000003E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04080807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04010005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x040A0309 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02070004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08070A0C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07080800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00060908 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07050000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00060306 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02050307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03010305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02020102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05030302 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x02020001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x05050104 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06020201 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x27242828 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x28282628 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000013 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000813 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004046D +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2300_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2300_emc.txt new file mode 100644 index 00000000..e905e312 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2300_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x0000008A +EMC_RFC_0 = 0x00000284 +EMC_RAS_0 = 0x00000061 +EMC_RP_0 = 0x0000002A +EMC_R2W_0 = 0x00000032 +EMC_W2R_0 = 0x0000002B +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x0000002A +EMC_WR_RCD_0 = 0x0000002A +EMC_RRD_0 = 0x00000012 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002C +EMC_QRST_0 = 0x0007000C +EMC_QSAFE_0 = 0x0000003E +EMC_RDV_0 = 0x00000044 +EMC_REFRESH_0 = 0x000022CA +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000019 +EMC_PDEX2RD_0 = 0x00000019 +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000021 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000048 +EMC_TXSR_0 = 0x00000296 +EMC_TCKE_0 = 0x00000014 +EMC_TFAW_0 = 0x00000045 +EMC_TRPAB_0 = 0x00000031 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001B +EMC_TREFBW_0 = 0x0000230A +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000045 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x023F0021 +EMC_MRS_WAIT_CNT_0 = 0x07FF003A +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80125975 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000014 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000015 +EMC_EINPUT_DURATION_0 = 0x00000026 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000023 +EMC_TPD_0 = 0x00000012 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D180000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000046 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000044 +EMC_RDV_EARLY_0 = 0x00000042 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x0118623F +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000044 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x000008B2 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004558 +EMC_TXSRDLL_0 = 0x00000296 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000036 +EMC_TR_RDV_MASK_0 = 0x00000046 +EMC_TR_QSAFE_0 = 0x0000003E +EMC_TR_QRST_0 = 0x0007000C +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x10000023 +EMC_OBDLY_0 = 0x10000006 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0B0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000036 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000142 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002F +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000B0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000B0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x45454647 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x44403E43 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000044 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x42444140 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x40453C3F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000003D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x4B4A4B4C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x48494B3D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000047 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x38414241 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x3F3E3935 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000003B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00050305 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02050102 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x41404041 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x4140413E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000040 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x0F10110E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x0C0E0A0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x45453F41 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x4341443F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000040 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03080806 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04010005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04090408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02070004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x07070A0B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07070800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050808 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07060000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00060206 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02050207 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02010304 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01020001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x06040403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06040005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x03020201 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x28252629 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x27282727 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x00080008 +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x0000000D +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000813 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004047E +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000B0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2333_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2333_emc.txt new file mode 100644 index 00000000..a8c855e6 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2333_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0x03200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x0000008C +EMC_RFC_0 = 0x0000028E +EMC_RAS_0 = 0x00000062 +EMC_RP_0 = 0x0000002A +EMC_R2W_0 = 0x00000032 +EMC_W2R_0 = 0x0000002B +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x0000002A +EMC_WR_RCD_0 = 0x0000002A +EMC_RRD_0 = 0x00000012 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002C +EMC_QRST_0 = 0x0007000B +EMC_QSAFE_0 = 0x0000003E +EMC_RDV_0 = 0x00000044 +EMC_REFRESH_0 = 0x0000234B +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000019 +EMC_PDEX2RD_0 = 0x00000019 +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000021 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000048 +EMC_TXSR_0 = 0x0000029F +EMC_TCKE_0 = 0x00000014 +EMC_TFAW_0 = 0x00000046 +EMC_TRPAB_0 = 0x00000031 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001B +EMC_TREFBW_0 = 0x0000238B +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000045 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02480021 +EMC_MRS_WAIT_CNT_0 = 0x07FF003A +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80040101 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000014 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000014 +EMC_EINPUT_DURATION_0 = 0x00000027 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000023 +EMC_TPD_0 = 0x00000012 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1E190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000046 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000044 +EMC_RDV_EARLY_0 = 0x00000042 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186248 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000044 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080A +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x000008D2 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004653 +EMC_TXSRDLL_0 = 0x000001CC +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000036 +EMC_TR_RDV_MASK_0 = 0x00000046 +EMC_TR_QSAFE_0 = 0x0000003E +EMC_TR_QRST_0 = 0x0007000B +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x10000023 +EMC_OBDLY_0 = 0x10000006 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0E0B +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000036 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000147 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A032010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x000E0006 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240028 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002F +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00140009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000B0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000B0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00270026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x46474747 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x45403F43 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000045 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x44464342 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x42473E41 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000003F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x4C4B4E4E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x494C4C3E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000004A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x3A434342 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x403F3B37 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000003E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x02070407 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03070304 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x42404143 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x4341423F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000041 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x11111311 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x0F100C0E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x46464142 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x4442453F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000041 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04080807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04010005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x03090408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02060003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x07070A0C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07080800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x01070909 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07060100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00060307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02060308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02030504 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x03030302 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05030403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06040105 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06020301 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x26242629 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x28262927 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000013 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000813 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040320 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000E0B +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2366_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2366_emc.txt new file mode 100644 index 00000000..c28c5180 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2366_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x0000008E +EMC_RFC_0 = 0x00000297 +EMC_RAS_0 = 0x00000064 +EMC_RP_0 = 0x0000001D +EMC_R2W_0 = 0x00000032 +EMC_W2R_0 = 0x0000002B +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x0000002B +EMC_WR_RCD_0 = 0x0000002B +EMC_RRD_0 = 0x00000012 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002E +EMC_QRST_0 = 0x0007000D +EMC_QSAFE_0 = 0x0000003F +EMC_RDV_0 = 0x00000045 +EMC_REFRESH_0 = 0x000023CB +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000019 +EMC_PDEX2RD_0 = 0x00000019 +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000022 +EMC_AR2PDEN_0 = 0x00000003 +EMC_RW2PDEN_0 = 0x00000048 +EMC_TXSR_0 = 0x000001CC +EMC_TCKE_0 = 0x00000014 +EMC_TFAW_0 = 0x00000047 +EMC_TRPAB_0 = 0x00000032 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001C +EMC_TREFBW_0 = 0x0000240B +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000046 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02500022 +EMC_MRS_WAIT_CNT_0 = 0x07FF003A +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80122C43 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000015 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000016 +EMC_EINPUT_DURATION_0 = 0x00000026 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000024 +EMC_TPD_0 = 0x00000012 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D180000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000047 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000045 +EMC_RDV_EARLY_0 = 0x00000037 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186250 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000039 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x000008F2 +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000474E +EMC_TXSRDLL_0 = 0x000002A9 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000037 +EMC_TR_RDV_MASK_0 = 0x0000003B +EMC_TR_QSAFE_0 = 0x0000003F +EMC_TR_QRST_0 = 0x0007000D +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030C +EMC_IBDLY_0 = 0x10000025 +EMC_OBDLY_0 = 0x10000006 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000037 +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000014C +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000012 +EMC_CMD_BRLSHFT_3_0 = 0x00000012 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A00A018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x88200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x00150009 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230030 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0013 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x00150009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000C0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000C0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00240027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x001E0022 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x07070909 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x06020004 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x06070504 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03070002 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0E0D0F0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0A0D0E00 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x3B454544 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x42413C38 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000028 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x04090608 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x05080505 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04020404 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x2C2C2D2A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x12131412 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x0F110D10 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x07080204 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06040701 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03080807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x050A0409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03050003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0707090B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07070700 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06040000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070406 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02050307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03010405 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02020102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05030403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x05040104 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x05020300 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x27242629 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x28262629 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00130013 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00090009 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000013 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000813 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x0004049F +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2400_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2400_emc.txt new file mode 100644 index 00000000..bace18ef --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2400_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000090 +EMC_RFC_0 = 0x000002A0 +EMC_RAS_0 = 0x00000065 +EMC_RP_0 = 0x0000002C +EMC_R2W_0 = 0x00000032 +EMC_W2R_0 = 0x0000002B +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x0000002C +EMC_WR_RCD_0 = 0x0000002C +EMC_RRD_0 = 0x00000012 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002E +EMC_QRST_0 = 0x0007000D +EMC_QSAFE_0 = 0x0000003F +EMC_RDV_0 = 0x00000045 +EMC_REFRESH_0 = 0x00002450 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000019 +EMC_PDEX2RD_0 = 0x00000019 +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000022 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000048 +EMC_TXSR_0 = 0x000002B2 +EMC_TCKE_0 = 0x00000014 +EMC_TFAW_0 = 0x00000048 +EMC_TRPAB_0 = 0x00000033 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001C +EMC_TREFBW_0 = 0x00002490 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000047 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02580022 +EMC_MRS_WAIT_CNT_0 = 0x07FF003A +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80122641 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000015 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000016 +EMC_EINPUT_DURATION_0 = 0x00000026 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000024 +EMC_TPD_0 = 0x00000012 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D180000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000047 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000045 +EMC_RDV_EARLY_0 = 0x00000043 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186258 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000045 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000914 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004850 +EMC_TXSRDLL_0 = 0x000002B2 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000037 +EMC_TR_RDV_MASK_0 = 0x00000047 +EMC_TR_QSAFE_0 = 0x0000003F +EMC_TR_QRST_0 = 0x0007000D +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x10000025 +EMC_OBDLY_0 = 0x10000006 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0B +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000037 +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000150 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x88204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000C0014 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0015000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230030 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0014 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0015000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000C0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000C0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0A0B0B0B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x0A050308 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x07080605 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x2B2E282A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0F0E1010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0B0E0F00 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x3D464745 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x43433D39 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000040 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x050A070A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x060A0607 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x06040506 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x06050503 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x14151613 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x12130F11 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000000E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x09090305 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x08050802 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04090907 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x03080307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x01050003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08080A0C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x08080900 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050807 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06040000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00060306 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02040308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02000102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02020102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05050504 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x05040105 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06030300 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x2525242A +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x27262425 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000A000A +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000014 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000814 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000404B0 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0B +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2433_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2433_emc.txt new file mode 100644 index 00000000..870de76b --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2433_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000092 +EMC_RFC_0 = 0x000002AA +EMC_RAS_0 = 0x00000067 +EMC_RP_0 = 0x0000002C +EMC_R2W_0 = 0x00000032 +EMC_W2R_0 = 0x0000002C +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x0000002C +EMC_WR_RCD_0 = 0x0000002C +EMC_RRD_0 = 0x00000013 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002E +EMC_QRST_0 = 0x0007000C +EMC_QSAFE_0 = 0x0000003F +EMC_RDV_0 = 0x00000045 +EMC_REFRESH_0 = 0x000024D1 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001A +EMC_PDEX2RD_0 = 0x0000001A +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000023 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000048 +EMC_TXSR_0 = 0x000002BC +EMC_TCKE_0 = 0x00000015 +EMC_TFAW_0 = 0x00000049 +EMC_TRPAB_0 = 0x00000034 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001C +EMC_TREFBW_0 = 0x00002511 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000048 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02610023 +EMC_MRS_WAIT_CNT_0 = 0x07FF003A +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80122B41 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000015 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000015 +EMC_EINPUT_DURATION_0 = 0x00000027 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000025 +EMC_TPD_0 = 0x00000013 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D180000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430020 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000047 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000045 +EMC_RDV_EARLY_0 = 0x00000043 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186261 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000045 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080A +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000934 +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000494B +EMC_TXSRDLL_0 = 0x000002BC +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000037 +EMC_TR_RDV_MASK_0 = 0x00000047 +EMC_TR_QSAFE_0 = 0x0000003F +EMC_TR_QRST_0 = 0x0007000C +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x10000025 +EMC_OBDLY_0 = 0x10000006 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0B +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000037 +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000155 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A01A018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x0008000D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0015000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230030 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0014 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0015000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000C0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000C0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0B0C0C0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x0B060409 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x080A0807 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x060C0205 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x100F1111 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0C101102 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000000E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x3D474846 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x45443F3A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000041 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x050A080A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x060B0607 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x2D2C2D2D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x07060603 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x16171815 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x13151012 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x0B0B0506 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x09070A03 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04090907 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04090408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x02060005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x07070A0C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07070800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00050808 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x06040100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03050409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03010404 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x03020102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05040503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04020003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06040104 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06030301 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x23232327 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x28252727 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000A000A +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000014 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000814 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000404C1 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0B +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2466_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2466_emc.txt new file mode 100644 index 00000000..089258db --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2466_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000094 +EMC_RFC_0 = 0x000002B3 +EMC_RAS_0 = 0x00000068 +EMC_RP_0 = 0x0000002D +EMC_R2W_0 = 0x00000032 +EMC_W2R_0 = 0x0000002C +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x0000002D +EMC_WR_RCD_0 = 0x0000002D +EMC_RRD_0 = 0x00000013 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002E +EMC_QRST_0 = 0x0007000C +EMC_QSAFE_0 = 0x0000003F +EMC_RDV_0 = 0x00000045 +EMC_REFRESH_0 = 0x00002551 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001A +EMC_PDEX2RD_0 = 0x0000001A +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000023 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000048 +EMC_TXSR_0 = 0x000002C5 +EMC_TCKE_0 = 0x00000015 +EMC_TFAW_0 = 0x0000004A +EMC_TRPAB_0 = 0x00000034 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001C +EMC_TREFBW_0 = 0x00002591 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000049 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02690023 +EMC_MRS_WAIT_CNT_0 = 0x07FF003A +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012041E +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000015 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000015 +EMC_EINPUT_DURATION_0 = 0x00000027 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000025 +EMC_TPD_0 = 0x00000013 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1E190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430021 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000047 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000045 +EMC_RDV_EARLY_0 = 0x00000043 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186269 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000045 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000954 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004A46 +EMC_TXSRDLL_0 = 0x000002C5 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000037 +EMC_TR_RDV_MASK_0 = 0x00000047 +EMC_TR_QSAFE_0 = 0x0000003F +EMC_TR_QRST_0 = 0x0007000C +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x10000025 +EMC_OBDLY_0 = 0x10000006 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000037 +EMC_QUSE_WIDTH_0 = 0x0000000A +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000015A +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x80204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000C0014 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230030 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000C0014 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000C0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000C0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00270027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0C0D0E0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x0C07060A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x090B0807 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x070D0306 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x11101313 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0E111202 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x3F494A48 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x4645413B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000043 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x070B080B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x080C0808 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x08070708 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x09070804 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x17181916 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x14151114 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x0C0C0607 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x0A070B04 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03080806 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x050A0409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03070005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0707090C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x06070800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x01060908 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07060100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00060207 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02040308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04010405 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02020102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x06030404 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04020003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x07060207 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x07040503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x2622272B +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x26282626 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00140014 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000A000A +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000014 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D181D18 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000814 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000404D1 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2500_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2500_emc.txt new file mode 100644 index 00000000..6f66cbe2 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2500_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000096 +EMC_RFC_0 = 0x000002BC +EMC_RAS_0 = 0x00000069 +EMC_RP_0 = 0x0000002D +EMC_R2W_0 = 0x00000033 +EMC_W2R_0 = 0x0000002C +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x0000002D +EMC_WR_RCD_0 = 0x0000002D +EMC_RRD_0 = 0x00000013 +EMC_REXT_0 = 0x0000001A +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002D +EMC_QRST_0 = 0x0007000B +EMC_QSAFE_0 = 0x0000003F +EMC_RDV_0 = 0x00000045 +EMC_REFRESH_0 = 0x000025D6 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001A +EMC_PDEX2RD_0 = 0x0000001A +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000023 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000048 +EMC_TXSR_0 = 0x000002CF +EMC_TCKE_0 = 0x00000015 +EMC_TFAW_0 = 0x0000004B +EMC_TRPAB_0 = 0x00000035 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001D +EMC_TREFBW_0 = 0x00002616 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000049 +EMC_WEXT_0 = 0x00000016 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02710023 +EMC_MRS_WAIT_CNT_0 = 0x07FF003A +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80040101 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000016 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000014 +EMC_EINPUT_DURATION_0 = 0x00000028 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000026 +EMC_TPD_0 = 0x00000013 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D180000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000047 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000045 +EMC_RDV_EARLY_0 = 0x00000043 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186271 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000045 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000975 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004B49 +EMC_TXSRDLL_0 = 0x000002CF +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000037 +EMC_TR_RDV_MASK_0 = 0x00000047 +EMC_TR_QSAFE_0 = 0x0000003F +EMC_TR_QRST_0 = 0x0007000B +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x10000024 +EMC_OBDLY_0 = 0x10000006 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000037 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000015E +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A01A010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230030 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000C0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000C0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00270027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220025 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00240026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0E0E1010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x0D09070C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x0B0D0A09 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x090E0508 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x12121414 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0F121404 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x404B4B4A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x4847413D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000044 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x080D0B0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x090E090A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x0A080A0B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x0B090A07 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x191A1A18 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x16171315 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x0E0E080A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x0C0A0D06 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03070706 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x05000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x03080407 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x01050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x07070A0C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07070800 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x01060A08 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x07050100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00060207 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02040207 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04010405 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02020102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x06030403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x04030103 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x08040504 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x2624232A +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x26292626 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000A000A +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000015 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080A080A +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000814 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000404E2 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2533_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2533_emc.txt new file mode 100644 index 00000000..fced5c9d --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2533_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x00000098 +EMC_RFC_0 = 0x000002C6 +EMC_RAS_0 = 0x0000006B +EMC_RP_0 = 0x0000002E +EMC_R2W_0 = 0x00000033 +EMC_W2R_0 = 0x0000002D +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x0000002E +EMC_WR_RCD_0 = 0x0000002E +EMC_RRD_0 = 0x00000013 +EMC_REXT_0 = 0x0000001C +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002D +EMC_QRST_0 = 0x00080009 +EMC_QSAFE_0 = 0x0000003F +EMC_RDV_0 = 0x00000045 +EMC_REFRESH_0 = 0x00002657 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001A +EMC_PDEX2RD_0 = 0x0000001A +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000024 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000048 +EMC_TXSR_0 = 0x000002D9 +EMC_TCKE_0 = 0x00000015 +EMC_TFAW_0 = 0x0000004C +EMC_TRPAB_0 = 0x00000036 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001D +EMC_TREFBW_0 = 0x00002697 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000004A +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x027A0024 +EMC_MRS_WAIT_CNT_0 = 0x07FF003A +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80040101 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000016 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000013 +EMC_EINPUT_DURATION_0 = 0x00000029 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000026 +EMC_TPD_0 = 0x00000013 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430031 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000047 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000045 +EMC_RDV_EARLY_0 = 0x00000043 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x0118627A +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000045 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000995 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004C44 +EMC_TXSRDLL_0 = 0x000002D9 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000037 +EMC_TR_RDV_MASK_0 = 0x00000047 +EMC_TR_QSAFE_0 = 0x0000003F +EMC_TR_QRST_0 = 0x00080009 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x10000023 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000037 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000292 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000163 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230031 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000C0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000C0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00260028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x10101111 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x0F0B090E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x0E0F0D0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x0B10070A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000008 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x15151717 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x11151607 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x424C4D4B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x4A49433E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000046 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x0A0F0C0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0B0F0B0B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000000E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x0C0B0B0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x0C0B0C08 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x1B1B1D1A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x181A1517 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000016 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x0F10090B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x0E0B0E08 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04080908 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04010007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x05090608 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03070005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x07070A0C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07070900 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00060908 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x05030000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03060409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03000304 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x05040503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04020005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06050105 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x03020201 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x25222228 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x26292526 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000A000A +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x0000000D +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000815 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040299 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2566_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2566_emc.txt new file mode 100644 index 00000000..4cbdc82c --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2566_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x0000009A +EMC_RFC_0 = 0x000002CF +EMC_RAS_0 = 0x0000006C +EMC_RP_0 = 0x0000002F +EMC_R2W_0 = 0x00000033 +EMC_W2R_0 = 0x0000002D +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x0000002F +EMC_WR_RCD_0 = 0x0000002F +EMC_RRD_0 = 0x00000014 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002E +EMC_QRST_0 = 0x0008000A +EMC_QSAFE_0 = 0x00000040 +EMC_RDV_0 = 0x00000046 +EMC_REFRESH_0 = 0x000026D7 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001B +EMC_PDEX2RD_0 = 0x0000001B +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000024 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000048 +EMC_TXSR_0 = 0x000002E2 +EMC_TCKE_0 = 0x00000016 +EMC_TFAW_0 = 0x0000004D +EMC_TRPAB_0 = 0x00000036 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001D +EMC_TREFBW_0 = 0x00002717 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000004C +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02820024 +EMC_MRS_WAIT_CNT_0 = 0x07FF003A +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012CDE6 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000016 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000014 +EMC_EINPUT_DURATION_0 = 0x00000029 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000027 +EMC_TPD_0 = 0x00000014 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000048 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000046 +EMC_RDV_EARLY_0 = 0x00000044 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186282 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000046 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x000009B5 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004D3F +EMC_TXSRDLL_0 = 0x000002E2 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000038 +EMC_TR_RDV_MASK_0 = 0x00000048 +EMC_TR_QSAFE_0 = 0x00000040 +EMC_TR_QRST_0 = 0x0008000A +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030D +EMC_IBDLY_0 = 0x10000024 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000038 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000168 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A01A010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00240029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230031 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000D0015 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0016000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000D0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000D0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00270027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x11111213 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x100C090F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000022 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x0F110E0E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x0D11090C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x17171919 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x13171808 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x030D0E0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x0B090400 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x0C110E11 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0D120D0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x0D0C0C0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x0D0C0D0A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x1D1D1E1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x1A1C1719 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000018 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x11120B0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x0F0C1009 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04090907 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x050A050A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03070004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0606090B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x07070700 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00060A09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x08060100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03050308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04010505 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x03020102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x06020402 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x08060307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x08050503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x23232729 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x26282626 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00150015 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000A000A +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000015 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000815 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040503 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2600_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2600_emc.txt new file mode 100644 index 00000000..b0f90152 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2600_emc.txt @@ -0,0 +1,87 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +emc_cfg = 0xF3200000 +emc_rc = 0x0000009C +emc_rfc = 0x000002D8 +emc_ras = 0x0000006E +emc_rp = 0x0000002F +emc_r2w = 0x00000033 +emc_w2r = 0x0000002D +emc_r2p = 0x00000010 +emc_w2p = 0x0000003B +emc_rd_rcd = 0x0000002F +emc_wr_rcd = 0x0000002F +emc_rrd = 0x00000014 +emc_rext = 0x0000001B +emc_qsafe = 0x00000040 +emc_refresh = 0x0000275C +emc_burst_refresh_num = 0x00000000 +emc_pdex2wr = 0x0000001B +emc_pdex2rd = 0x0000001B +emc_pchg2pden = 0x00000005 +emc_act2pden = 0x00000025 +emc_ar2pden = 0x00000005 +emc_rw2pden = 0x00000048 +emc_txsr = 0x000002EC +emc_tcke = 0x00000016 +emc_tfaw = 0x0000004E +emc_trpab = 0x00000037 +emc_tclkstable = 0x00000004 +emc_tclkstop = 0x0000001E +emc_trefbw = 0x0000279C +emc_tppd = 0x00000004 +emc_odt_write = 0x00000000 +emc_pdex2mrr = 0x0000004C +emc_wext = 0x00000019 +emc_rfc_slr = 0x00000000 +emc_mrs_wait_cnt2 = 0x028A0025 +emc_mrs_wait_cnt = 0x07FF003B +emc_mrs = 0x00000000 +emc_emrs = 0x00000000 +emc_mrw = 0x00170040 +emc_fbio_spare = 0x00000012 +emc_fbio_cfg5 = 0x9160A00D +emc_pdex2cke = 0x00000003 +emc_cke2pden = 0x00000017 +emc_r2r = 0x00000000 +emc_einput = 0x00000014 +emc_einput_duration = 0x00000029 +emc_puterm_extra = 0x00000001 +emc_tckesr = 0x00000027 +emc_tpd = 0x00000014 +emc_cfg_2 = 0x0011083D +emc_cfg_dig_dll = 0x002C03A9 +emc_cfg_dig_dll_period = 0x00008000 +emc_rdv_mask = 0x00000048 +emc_wdv_mask = 0x00000012 +emc_rdv_early_mask = 0x00000046 +emc_rdv_early = 0x00000044 +emc_fdpd_ctrl_dq = 0x8020221F +emc_fdpd_ctrl_cmd = 0x0220F40F +emc_sel_dpd_ctrl = 0x0004000C +emc_pre_refresh_req_cnt = 0x000009D7 +emc_dyn_self_ref_control = 0x80004E41 +emc_txsrdll = 0x000002EC +emc_ibdly = 0x10000024 +emc_obdly = 0x10000004 +emc_txdsrvttgen = 0x00000000 +emc_we_duration = 0x0000000E +emc_ws_duration = 0x00000008 +emc_wev = 0x0000000E +emc_cfg_3 = 0x00000040 +emc_wdv_chk = 0x00000006 +emc_cfg_pipe_2 = 0x00000000 +emc_cfg_pipe_1 = 0x0FFF0000 +emc_cfg_pipe = 0x0FFF0000 +emc_quse_width = 0x0000000B +emc_puterm_width = 0x80000000 +emc_fbio_cfg7 = 0x00003BFF +emc_rfcpb = 0x0000016C +emc_ccdmw = 0x00000020 +emc_config_sample_delay = 0x00000020 +emc_wdv = 0x00000012 +emc_quse = 0x0000002E +emc_qrst = 0x0008000A +emc_rdv = 0x00000046 +emc_wsv = 0x00000010 +emc_qpop = 0x00000038 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2633_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2633_emc.txt new file mode 100644 index 00000000..733284af --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2633_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x0000009E +EMC_RFC_0 = 0x000002E2 +EMC_RAS_0 = 0x0000006F +EMC_RP_0 = 0x00000030 +EMC_R2W_0 = 0x00000033 +EMC_W2R_0 = 0x0000002E +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000030 +EMC_WR_RCD_0 = 0x00000030 +EMC_RRD_0 = 0x00000014 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002E +EMC_QRST_0 = 0x00080009 +EMC_QSAFE_0 = 0x00000040 +EMC_RDV_0 = 0x00000046 +EMC_REFRESH_0 = 0x000027DD +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001B +EMC_PDEX2RD_0 = 0x0000001B +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000025 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000048 +EMC_TXSR_0 = 0x000002F5 +EMC_TCKE_0 = 0x00000016 +EMC_TFAW_0 = 0x0000004F +EMC_TRPAB_0 = 0x00000038 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001E +EMC_TREFBW_0 = 0x0000281D +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000004D +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02930025 +EMC_MRS_WAIT_CNT_0 = 0x07FF003B +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012ACC4 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000017 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000013 +EMC_EINPUT_DURATION_0 = 0x0000002A +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000028 +EMC_TPD_0 = 0x00000014 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1E190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000048 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000046 +EMC_RDV_EARLY_0 = 0x00000044 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186293 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000046 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x000009F7 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80004F3C +EMC_TXSRDLL_0 = 0x000002F5 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000038 +EMC_TR_RDV_MASK_0 = 0x00000048 +EMC_TR_QSAFE_0 = 0x00000040 +EMC_TR_QRST_0 = 0x00080009 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030E +EMC_IBDLY_0 = 0x10000024 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0D0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000038 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000171 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0x88200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000D0016 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0017000B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230031 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000D0016 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0017000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000D0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000D0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00280029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00210027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x15151616 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x130F0D13 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x12141110 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x0F150C0F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x1A1A1B1B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x171A1B0B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x050F110F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x0C0C0702 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x0F141214 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x10141011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x100F0F10 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x100F100C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x2020211F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x1C1E191C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000001B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x14150E10 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x1210130C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x04090909 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x05010006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x050A050A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03080005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08070A0F +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0A0A0900 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00080C09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x09080300 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00080408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03060409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04040606 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x04040303 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x06020403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x05040104 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x05040200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x27252628 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x28272726 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00170017 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000016 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000816 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040525 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000D0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2666_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2666_emc.txt new file mode 100644 index 00000000..cc9ee809 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2666_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000A0 +EMC_RFC_0 = 0x000002EB +EMC_RAS_0 = 0x00000070 +EMC_RP_0 = 0x00000030 +EMC_R2W_0 = 0x00000033 +EMC_W2R_0 = 0x0000002E +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000030 +EMC_WR_RCD_0 = 0x00000030 +EMC_RRD_0 = 0x00000014 +EMC_REXT_0 = 0x0000001B +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002E +EMC_QRST_0 = 0x00080009 +EMC_QSAFE_0 = 0x00000040 +EMC_RDV_0 = 0x00000046 +EMC_REFRESH_0 = 0x0000285D +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001B +EMC_PDEX2RD_0 = 0x0000001B +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000026 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000048 +EMC_TXSR_0 = 0x000002FF +EMC_TCKE_0 = 0x00000016 +EMC_TFAW_0 = 0x00000050 +EMC_TRPAB_0 = 0x00000038 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001E +EMC_TREFBW_0 = 0x0000289D +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000004D +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x029B0026 +EMC_MRS_WAIT_CNT_0 = 0x07FF003B +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012BAD6 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000017 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000013 +EMC_EINPUT_DURATION_0 = 0x0000002A +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000028 +EMC_TPD_0 = 0x00000014 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000048 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000046 +EMC_RDV_EARLY_0 = 0x00000044 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x0118629B +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000046 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000A17 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005037 +EMC_TXSRDLL_0 = 0x000002FF +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000038 +EMC_TR_RDV_MASK_0 = 0x00000048 +EMC_TR_QSAFE_0 = 0x00000040 +EMC_TR_QRST_0 = 0x00080009 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030E +EMC_IBDLY_0 = 0x10000024 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000038 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000176 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A01A010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000D0016 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0017000B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230032 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000D0016 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0017000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000D0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000D0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220023 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00280029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x16171717 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x15100E14 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x12151212 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x11160D10 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000000E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x1B1B1D1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x181B1C0C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x07111311 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x0F0D0903 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x10161216 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x11161112 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x11101012 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1111110D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x22222320 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x34353233 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000001C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x16160F11 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x2D2B2E29 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x05080909 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x050B050B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03090005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08080B0F +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x0A0A0A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00080B09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x09080200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00090408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02060408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x05030607 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x04040304 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x06020303 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06050206 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x07050401 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x25252727 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x27252627 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00170017 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000016 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000816 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040535 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2700_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2700_emc.txt new file mode 100644 index 00000000..f34106a0 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2700_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000A2 +EMC_RFC_0 = 0x000002F4 +EMC_RAS_0 = 0x00000072 +EMC_RP_0 = 0x00000031 +EMC_R2W_0 = 0x00000033 +EMC_W2R_0 = 0x0000002E +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000031 +EMC_WR_RCD_0 = 0x00000031 +EMC_RRD_0 = 0x00000015 +EMC_REXT_0 = 0x0000001C +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002D +EMC_QRST_0 = 0x00080008 +EMC_QSAFE_0 = 0x00000040 +EMC_RDV_0 = 0x00000046 +EMC_REFRESH_0 = 0x000028E2 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001C +EMC_PDEX2RD_0 = 0x0000001C +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000026 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000048 +EMC_TXSR_0 = 0x00000309 +EMC_TCKE_0 = 0x00000017 +EMC_TFAW_0 = 0x00000051 +EMC_TRPAB_0 = 0x00000039 +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001E +EMC_TREFBW_0 = 0x00002922 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000004F +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02A30026 +EMC_MRS_WAIT_CNT_0 = 0x07FF003B +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x801291A9 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000017 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000012 +EMC_EINPUT_DURATION_0 = 0x0000002B +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000029 +EMC_TPD_0 = 0x00000015 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000048 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000046 +EMC_RDV_EARLY_0 = 0x00000044 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862A3 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000046 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000A38 +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000513A +EMC_TXSRDLL_0 = 0x00000309 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000038 +EMC_TR_RDV_MASK_0 = 0x00000048 +EMC_TR_QSAFE_0 = 0x00000040 +EMC_TR_QRST_0 = 0x00080008 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030E +EMC_IBDLY_0 = 0x10000023 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0D09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000038 +EMC_QUSE_WIDTH_0 = 0x0000000C +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000017A +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC0200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000E0016 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0018000B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230032 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000E0016 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0018000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000D0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000D0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00280029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00230026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00210027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x17181818 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x16110F15 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000016 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x14171313 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x12180E11 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000000F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x1C1C1E1E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x1A1C1E0D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000001B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x08121512 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x100E0A04 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x11171417 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x12171313 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000016 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x13121213 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x2C2C2C2A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x23232422 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x34353234 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000001D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x18181112 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x1512160F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000012 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03050606 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x03000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x050B050B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03090005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08070A0E +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x09090900 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x01080B09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x09070200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00040205 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03060409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02000102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x00010001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x08020303 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x03010002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x04030103 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x05040201 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x24242627 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x26262825 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00160016 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x00080008 +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00050005 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00180018 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x0000000D +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000816 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040320 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000D09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2733_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2733_emc.txt new file mode 100644 index 00000000..3902d5ab --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2733_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000A4 +EMC_RFC_0 = 0x000002FE +EMC_RAS_0 = 0x00000073 +EMC_RP_0 = 0x00000032 +EMC_R2W_0 = 0x00000033 +EMC_W2R_0 = 0x0000002F +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000032 +EMC_WR_RCD_0 = 0x00000032 +EMC_RRD_0 = 0x00000015 +EMC_REXT_0 = 0x0000001C +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002D +EMC_QRST_0 = 0x00080007 +EMC_QSAFE_0 = 0x00000040 +EMC_RDV_0 = 0x00000046 +EMC_REFRESH_0 = 0x00002963 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001C +EMC_PDEX2RD_0 = 0x0000001C +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000027 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000048 +EMC_TXSR_0 = 0x00000312 +EMC_TCKE_0 = 0x00000017 +EMC_TFAW_0 = 0x00000052 +EMC_TRPAB_0 = 0x0000003A +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x000029A3 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000050 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02AC0027 +EMC_MRS_WAIT_CNT_0 = 0x07FF003B +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80122B41 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000018 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000011 +EMC_EINPUT_DURATION_0 = 0x0000002C +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x00000029 +EMC_TPD_0 = 0x00000015 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1E190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000048 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000046 +EMC_RDV_EARLY_0 = 0x00000044 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862AC +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000039 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000A58 +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000308C +EMC_TXSRDLL_0 = 0x00000312 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000038 +EMC_TR_RDV_MASK_0 = 0x00000048 +EMC_TR_QSAFE_0 = 0x00000040 +EMC_TR_QRST_0 = 0x00080007 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030E +EMC_IBDLY_0 = 0x10000023 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C0A +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000038 +EMC_QUSE_WIDTH_0 = 0x0000000C +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x000000E0 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A002010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000E0017 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0018000B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230032 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x0008000D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0018000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000D0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000D0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220023 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00270029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00210028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x19191A1A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x18131117 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000018 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x2C2E2C2C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x2B2E292A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x1D1D1F1F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x1A1E1E0E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000001B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x09141514 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x12100B06 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000000E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x13191619 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x2D2F2C2D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000018 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x2D2C2D2D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x15141411 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x25252623 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x20231E20 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000032 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x1A191114 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x2D2B2E29 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x05090909 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x060A060A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03080006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08080B0F +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x09090A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00070A08 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x08050000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03060309 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04000306 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01030003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x08030404 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x05020103 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06050005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06030401 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x23232628 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x24262223 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00170017 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000E000E +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00180018 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000017 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x0000080D +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040557 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C0A +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2766_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2766_emc.txt new file mode 100644 index 00000000..ba1964d4 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2766_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000A6 +EMC_RFC_0 = 0x00000307 +EMC_RAS_0 = 0x00000075 +EMC_RP_0 = 0x00000032 +EMC_R2W_0 = 0x00000033 +EMC_W2R_0 = 0x0000002F +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000032 +EMC_WR_RCD_0 = 0x00000032 +EMC_RRD_0 = 0x00000015 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002F +EMC_QRST_0 = 0x00080009 +EMC_QSAFE_0 = 0x00000041 +EMC_RDV_0 = 0x00000047 +EMC_REFRESH_0 = 0x000029E3 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001C +EMC_PDEX2RD_0 = 0x0000001C +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000027 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000048 +EMC_TXSR_0 = 0x0000031C +EMC_TCKE_0 = 0x00000017 +EMC_TFAW_0 = 0x00000053 +EMC_TRPAB_0 = 0x0000003B +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002A23 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000050 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02B40027 +EMC_MRS_WAIT_CNT_0 = 0x07FF003B +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80127289 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000018 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000013 +EMC_EINPUT_DURATION_0 = 0x0000002B +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002A +EMC_TPD_0 = 0x00000015 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1E190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000049 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000047 +EMC_RDV_EARLY_0 = 0x00000045 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862B4 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000047 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000A78 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005330 +EMC_TXSRDLL_0 = 0x0000031C +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000039 +EMC_TR_RDV_MASK_0 = 0x00000049 +EMC_TR_QSAFE_0 = 0x00000041 +EMC_TR_QRST_0 = 0x00080009 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030E +EMC_IBDLY_0 = 0x10000025 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000039 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000184 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000E0017 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0018000B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230032 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000E0017 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0018000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x00080000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000009 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000E0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00280029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00240027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x001F0022 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x1A1A1B1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x19141218 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x171B1717 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x2B2E292A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x1F1E2120 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x1B1E200F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000031 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x0B161615 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x13110D07 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000010 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x151B181B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x151B1716 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x16141616 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x15151612 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x27272725 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x27282527 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000020 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x1B1A1314 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x2C2B2E29 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0509090A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x04000007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x050A050A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03080005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08080B0F +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x09090A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00070C09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x09070100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00080409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02060409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04040607 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x05040403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x08030403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04030003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x06050105 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x06040401 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x25232628 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x25252523 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00170017 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000E000E +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00180018 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000017 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x0000080D +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040567 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2800_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2800_emc.txt new file mode 100644 index 00000000..0deab2f3 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2800_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000A8 +EMC_RFC_0 = 0x00000310 +EMC_RAS_0 = 0x00000076 +EMC_RP_0 = 0x00000033 +EMC_R2W_0 = 0x00000033 +EMC_W2R_0 = 0x0000002F +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000033 +EMC_WR_RCD_0 = 0x00000033 +EMC_RRD_0 = 0x00000015 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002F +EMC_QRST_0 = 0x0006000C +EMC_QSAFE_0 = 0x00000041 +EMC_RDV_0 = 0x00000047 +EMC_REFRESH_0 = 0x00002A68 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001C +EMC_PDEX2RD_0 = 0x0000001C +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000028 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000049 +EMC_TXSR_0 = 0x00000325 +EMC_TCKE_0 = 0x00000017 +EMC_TFAW_0 = 0x00000054 +EMC_TRPAB_0 = 0x0000003B +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002AA8 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000051 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02BC0028 +EMC_MRS_WAIT_CNT_0 = 0x07FF003B +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80122B42 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000018 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000013 +EMC_EINPUT_DURATION_0 = 0x0000002B +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002A +EMC_TPD_0 = 0x00000015 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430021 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000049 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000047 +EMC_RDV_EARLY_0 = 0x00000045 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862BC +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000047 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000A9A +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005432 +EMC_TXSRDLL_0 = 0x00000325 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000039 +EMC_TR_RDV_MASK_0 = 0x00000049 +EMC_TR_QSAFE_0 = 0x00000041 +EMC_TR_QRST_0 = 0x00080009 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030F +EMC_IBDLY_0 = 0x10000025 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0D09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000039 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000188 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A002010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000E0017 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0019000B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230032 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000E0017 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0019000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000E0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000E0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00250028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00280029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00240027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x1C1B1C1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x1A151319 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000002D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x181C1818 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x161B1215 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000013 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x21212323 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x1D212211 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x0000001F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x0C161816 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x14120E08 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000011 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x151B191B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x2C2F2C2D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000001B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x17161717 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x17171613 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x28282A27 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x25272123 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000021 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x1B1C1416 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x18161A13 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000002A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03040606 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x05010006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x090C050C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x060A0007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08080A0F +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x09090A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x01060707 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x08070100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00080409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03070509 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04040706 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x06040403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x09030404 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x05030103 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x08050107 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x08040603 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x25222326 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x23262523 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00170017 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000E000E +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00190019 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000017 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000817 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040578 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000D09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2833_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2833_emc.txt new file mode 100644 index 00000000..cf78146b --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2833_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000AA +EMC_RFC_0 = 0x0000031A +EMC_RAS_0 = 0x00000077 +EMC_RP_0 = 0x00000033 +EMC_R2W_0 = 0x00000033 +EMC_W2R_0 = 0x00000030 +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000033 +EMC_WR_RCD_0 = 0x00000033 +EMC_RRD_0 = 0x00000016 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x0000000E +EMC_QUSE_0 = 0x0000002F +EMC_QRST_0 = 0x00080008 +EMC_QSAFE_0 = 0x00000041 +EMC_RDV_0 = 0x00000033 +EMC_REFRESH_0 = 0x00002AE9 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001D +EMC_PDEX2RD_0 = 0x0000001D +EMC_PCHG2PDEN_0 = 0x00000005 +EMC_ACT2PDEN_0 = 0x00000028 +EMC_AR2PDEN_0 = 0x00000005 +EMC_RW2PDEN_0 = 0x00000049 +EMC_TXSR_0 = 0x0000032F +EMC_TCKE_0 = 0x00000018 +EMC_TFAW_0 = 0x00000055 +EMC_TRPAB_0 = 0x0000003C +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002B29 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000052 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02C50028 +EMC_MRS_WAIT_CNT_0 = 0x07FF003B +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80040101 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000003 +EMC_CKE2PDEN_0 = 0x00000019 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000012 +EMC_EINPUT_DURATION_0 = 0x0000002C +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002B +EMC_TPD_0 = 0x00000016 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1E190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000049 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000047 +EMC_RDV_EARLY_0 = 0x00000045 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862C5 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000033 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F070B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000ABA +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000552D +EMC_TXSRDLL_0 = 0x0000032F +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000039 +EMC_TR_RDV_MASK_0 = 0x00000049 +EMC_TR_QSAFE_0 = 0x00000041 +EMC_TR_QRST_0 = 0x00080008 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030F +EMC_IBDLY_0 = 0x1000001C +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x0000000C +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0D09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000039 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x000000E0 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A082010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8280002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000E0017 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0019000B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230033 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000E0017 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0019000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0003000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000E0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0003000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000E0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00240028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00280029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x1C1C1C1D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x1B17131A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000001B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x1A1C1A1A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x181C1416 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x22222524 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x1E232412 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000030 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x0D181A17 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x2A2A2624 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000028 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x2C2F2D2F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x181C181A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000002E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x2D2C2C2D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x19171914 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000002C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x36363736 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x25282225 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000023 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x1D1D1618 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x1A171B14 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000017 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x050A0A09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x06000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x080B050B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x05090006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08080A0F +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x09090A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00070C09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x08070100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00090408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03070509 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x03000305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x00020002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x08030403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x05020103 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x09060107 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x08040603 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x25232227 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x23252124 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00170017 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000E000E +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000B000B +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00190019 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000017 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000817 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040589 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000D09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2866_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2866_emc.txt new file mode 100644 index 00000000..6f03c6ad --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2866_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000AC +EMC_RFC_0 = 0x00000323 +EMC_RAS_0 = 0x00000079 +EMC_RP_0 = 0x00000034 +EMC_R2W_0 = 0x00000033 +EMC_W2R_0 = 0x00000030 +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000034 +EMC_WR_RCD_0 = 0x00000034 +EMC_RRD_0 = 0x00000016 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002F +EMC_QRST_0 = 0x00080008 +EMC_QSAFE_0 = 0x00000041 +EMC_RDV_0 = 0x00000047 +EMC_REFRESH_0 = 0x00002B69 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001E +EMC_PDEX2RD_0 = 0x0000001E +EMC_PCHG2PDEN_0 = 0x00000006 +EMC_ACT2PDEN_0 = 0x00000029 +EMC_AR2PDEN_0 = 0x00000006 +EMC_RW2PDEN_0 = 0x00000049 +EMC_TXSR_0 = 0x00000338 +EMC_TCKE_0 = 0x00000018 +EMC_TFAW_0 = 0x00000056 +EMC_TRPAB_0 = 0x0000003D +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002BA9 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000054 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02CD0029 +EMC_MRS_WAIT_CNT_0 = 0x07FF003C +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012485F +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000004 +EMC_CKE2PDEN_0 = 0x00000019 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000012 +EMC_EINPUT_DURATION_0 = 0x0000002C +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002B +EMC_TPD_0 = 0x00000016 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1E190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000049 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000047 +EMC_RDV_EARLY_0 = 0x00000045 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862CD +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000047 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000608 +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005628 +EMC_TXSRDLL_0 = 0x00000338 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000039 +EMC_TR_RDV_MASK_0 = 0x00000049 +EMC_TR_QSAFE_0 = 0x00000041 +EMC_TR_QRST_0 = 0x00080008 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030F +EMC_IBDLY_0 = 0x10000025 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C08 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000039 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x00000192 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A01A010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC0200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000F0018 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0019000C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230033 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000F0018 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0019000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0004000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000E0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0004000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000E0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00250028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x00280029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00230028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x001F0022 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x201F1F20 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x1D19171D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000022 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x1B1D1B1B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x191D1518 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000016 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x24242625 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x20242513 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000022 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x0E191A19 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x1816100B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x181F1C1F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x191E1B1A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000001D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x1B191A1B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1A1A1A16 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x2B2B2D29 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x27282426 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000024 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x1F1F171A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x1B191D16 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000018 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x040A0B0A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x06000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x0A0C060C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x060A0007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08080B0F +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x09090A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00080C09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x08060100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00090509 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0308060A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04040606 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x05040302 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x07030403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04020003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x0A060109 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x0A040705 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x23232227 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x21252524 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00180018 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000F000F +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00190019 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000018 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x0000080D +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040599 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C08 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2900_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2900_emc.txt new file mode 100644 index 00000000..43254751 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2900_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000AE +EMC_RFC_0 = 0x0000032C +EMC_RAS_0 = 0x0000007A +EMC_RP_0 = 0x00000035 +EMC_R2W_0 = 0x00000034 +EMC_W2R_0 = 0x00000030 +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000035 +EMC_WR_RCD_0 = 0x00000035 +EMC_RRD_0 = 0x00000016 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002F +EMC_QRST_0 = 0x00080008 +EMC_QSAFE_0 = 0x00000041 +EMC_RDV_0 = 0x00000047 +EMC_REFRESH_0 = 0x00002BEE +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001E +EMC_PDEX2RD_0 = 0x0000001E +EMC_PCHG2PDEN_0 = 0x00000006 +EMC_ACT2PDEN_0 = 0x00000029 +EMC_AR2PDEN_0 = 0x00000006 +EMC_RW2PDEN_0 = 0x00000049 +EMC_TXSR_0 = 0x00000342 +EMC_TCKE_0 = 0x00000018 +EMC_TFAW_0 = 0x00000057 +EMC_TRPAB_0 = 0x0000003D +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002C2E +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000055 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02D50029 +EMC_MRS_WAIT_CNT_0 = 0x07FF003C +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80123C53 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000004 +EMC_CKE2PDEN_0 = 0x00000019 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000012 +EMC_EINPUT_DURATION_0 = 0x0000002C +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002C +EMC_TPD_0 = 0x00000016 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0F430025 +EMC_CFG_2_0 = 0x00110835 +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000003B +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000039 +EMC_RDV_EARLY_0 = 0x00000045 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862D5 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000047 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000AFB +EMC_DYN_SELF_REF_CONTROL_0 = 0x8000572B +EMC_TXSRDLL_0 = 0x00000342 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000039 +EMC_TR_RDV_MASK_0 = 0x00000049 +EMC_TR_QSAFE_0 = 0x00000041 +EMC_TR_QRST_0 = 0x00080008 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030F +EMC_IBDLY_0 = 0x10000025 +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000039 +EMC_QUSE_WIDTH_0 = 0x0000000B +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x000000E0 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000F0018 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x0019000C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230033 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000F0018 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x0019000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0004000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000E0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0004000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000E0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00250028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x0028002A +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00230028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00210028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x20202021 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x1E19171E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000001E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x1C1E1B1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x1B1E1619 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000017 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x26262827 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x22252716 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000024 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x0F1A1B19 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x1817110B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000014 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x191E1C1F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x1A1E1B1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000001E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x1B1A1A1B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1A1A1B17 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x2D2D2E2B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x282A2527 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000025 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x211F181B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x1C1A1E16 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x050B0B0A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x06000007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x090B050C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x060A0007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08090C10 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x09090A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00080C0A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x09070100 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00090509 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x01040105 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04040606 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x05030403 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x08050504 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x05040005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x07050006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x07030401 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x22232327 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x25252023 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000F000F +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00060006 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x00190019 +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x0000000D +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x070B070B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000818 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040320 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2933_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2933_emc.txt new file mode 100644 index 00000000..56a60afc --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2933_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000B0 +EMC_RFC_0 = 0x00000336 +EMC_RAS_0 = 0x0000007C +EMC_RP_0 = 0x00000035 +EMC_R2W_0 = 0x00000034 +EMC_W2R_0 = 0x00000031 +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000035 +EMC_WR_RCD_0 = 0x00000035 +EMC_RRD_0 = 0x00000016 +EMC_REXT_0 = 0x0000001C +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002E +EMC_QRST_0 = 0x00080006 +EMC_QSAFE_0 = 0x00000041 +EMC_RDV_0 = 0x00000047 +EMC_REFRESH_0 = 0x00002C6F +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001E +EMC_PDEX2RD_0 = 0x0000001E +EMC_PCHG2PDEN_0 = 0x00000006 +EMC_ACT2PDEN_0 = 0x0000002A +EMC_AR2PDEN_0 = 0x00000006 +EMC_RW2PDEN_0 = 0x00000049 +EMC_TXSR_0 = 0x0000034C +EMC_TCKE_0 = 0x00000018 +EMC_TFAW_0 = 0x00000058 +EMC_TRPAB_0 = 0x0000003E +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002CAF +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000055 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02DE002A +EMC_MRS_WAIT_CNT_0 = 0x07FF003C +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80123147 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000004 +EMC_CKE2PDEN_0 = 0x00000019 +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000010 +EMC_EINPUT_DURATION_0 = 0x0000002E +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002C +EMC_TPD_0 = 0x00000016 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1E190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x00000049 +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000047 +EMC_RDV_EARLY_0 = 0x00000045 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862DE +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000047 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000B1B +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005826 +EMC_TXSRDLL_0 = 0x0000034C +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x00000039 +EMC_TR_RDV_MASK_0 = 0x00000049 +EMC_TR_QSAFE_0 = 0x00000041 +EMC_TR_QRST_0 = 0x00080006 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030F +EMC_IBDLY_0 = 0x10000024 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C07 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x00000039 +EMC_QUSE_WIDTH_0 = 0x0000000C +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x0000019B +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000F0018 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x001A000C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230033 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000F0018 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x001A000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0004000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000F0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x00020007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000F0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00250029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x0029002A +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00230027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x21212022 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x1F1A181F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000001E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x1D201C1D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x1B1F181A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000018 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x28282A29 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x24262817 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000025 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x101B1E1A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x1918120D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x1B211E21 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x1B201C1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000001F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x1D1B1C1D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1B1C1C19 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000001B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x2F2F302D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x2A2C2729 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000027 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x2222191C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x1E1C1F18 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000001B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03050606 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x06010007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04050305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x06060709 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x09090A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00080E0B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x0A090300 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00080409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0307040A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x04030607 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x04040303 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x07050603 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x05040005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x09050107 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x09030603 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x25212224 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x22232422 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00180018 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000F000F +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x001A001A +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000018 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000818 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000405BB +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C07 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2966_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2966_emc.txt new file mode 100644 index 00000000..df5898eb --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/2966_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000B2 +EMC_RFC_0 = 0x0000033F +EMC_RAS_0 = 0x0000007D +EMC_RP_0 = 0x00000036 +EMC_R2W_0 = 0x00000034 +EMC_W2R_0 = 0x00000031 +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000036 +EMC_WR_RCD_0 = 0x00000036 +EMC_RRD_0 = 0x00000017 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002F +EMC_QRST_0 = 0x00080007 +EMC_QSAFE_0 = 0x00000042 +EMC_RDV_0 = 0x00000048 +EMC_REFRESH_0 = 0x00002CEF +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x0000001F +EMC_PDEX2RD_0 = 0x0000001F +EMC_PCHG2PDEN_0 = 0x00000006 +EMC_ACT2PDEN_0 = 0x0000002A +EMC_AR2PDEN_0 = 0x00000006 +EMC_RW2PDEN_0 = 0x00000049 +EMC_TXSR_0 = 0x00000355 +EMC_TCKE_0 = 0x00000019 +EMC_TFAW_0 = 0x00000059 +EMC_TRPAB_0 = 0x0000003F +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002D2F +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000057 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02E6002A +EMC_MRS_WAIT_CNT_0 = 0x07FF003C +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012263C +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000004 +EMC_CKE2PDEN_0 = 0x0000001A +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000011 +EMC_EINPUT_DURATION_0 = 0x0000002E +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002D +EMC_TPD_0 = 0x00000017 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000004A +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000048 +EMC_RDV_EARLY_0 = 0x00000046 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x00290534 +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862E6 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000048 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000B3B +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005921 +EMC_TXSRDLL_0 = 0x00000355 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000002B +EMC_TR_RDV_MASK_0 = 0x0000004A +EMC_TR_QSAFE_0 = 0x00000033 +EMC_TR_QRST_0 = 0x0006000C +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E0030F +EMC_IBDLY_0 = 0x10000025 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000003A +EMC_QUSE_WIDTH_0 = 0x0000000C +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x000001A0 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A01A018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000F0019 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x001A000C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00210029 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x0008000D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x000E0006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000F0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x00000005 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000003 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x00020007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000F0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00220023 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x0029002A +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x23232324 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x2D2B292D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000020 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x1E221E1D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x1C22191C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x33323333 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x24282A17 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000025 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x1B212120 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x1B19140E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000018 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x1B211D22 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x1C211D1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000022 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x1E1C1D1E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1D1C1D1A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000001C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x3030322E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x2B2D272B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000029 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x2F2E2B2C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x2D2B2E29 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000001B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x03050606 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x03000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x04050305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x06060709 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x09090B00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00080D0A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x09080200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x000B0608 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03090909 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02010102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x02040103 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x09040603 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x05030005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x04030103 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x03020201 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x23232427 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x28272523 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x00080008 +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00060006 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x001A001A +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x0000000D +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000818 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040320 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/3000_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/3000_emc.txt new file mode 100644 index 00000000..93004157 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/3000_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000B4 +EMC_RFC_0 = 0x00000348 +EMC_RAS_0 = 0x0000007E +EMC_RP_0 = 0x00000036 +EMC_R2W_0 = 0x00000034 +EMC_W2R_0 = 0x00000031 +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000036 +EMC_WR_RCD_0 = 0x00000036 +EMC_RRD_0 = 0x00000017 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002F +EMC_QRST_0 = 0x00080007 +EMC_QSAFE_0 = 0x00000042 +EMC_RDV_0 = 0x00000048 +EMC_REFRESH_0 = 0x00002D74 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000020 +EMC_PDEX2RD_0 = 0x00000020 +EMC_PCHG2PDEN_0 = 0x00000006 +EMC_ACT2PDEN_0 = 0x0000002A +EMC_AR2PDEN_0 = 0x00000006 +EMC_RW2PDEN_0 = 0x00000049 +EMC_TXSR_0 = 0x0000035F +EMC_TCKE_0 = 0x00000019 +EMC_TFAW_0 = 0x0000005A +EMC_TRPAB_0 = 0x0000003F +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002DB4 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000058 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02EE002A +EMC_MRS_WAIT_CNT_0 = 0x07FF003C +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80121B31 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000004 +EMC_CKE2PDEN_0 = 0x0000001A +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000011 +EMC_EINPUT_DURATION_0 = 0x0000002E +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002D +EMC_TPD_0 = 0x00000017 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430021 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000004A +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000048 +EMC_RDV_EARLY_0 = 0x00000046 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862EE +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000048 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000B5D +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005A23 +EMC_TXSRDLL_0 = 0x0000035F +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000003A +EMC_TR_RDV_MASK_0 = 0x0000004A +EMC_TR_QSAFE_0 = 0x00000042 +EMC_TR_QRST_0 = 0x00080007 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E00310 +EMC_IBDLY_0 = 0x10000025 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C08 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000003A +EMC_QUSE_WIDTH_0 = 0x0000000C +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x000001A4 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8204002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000F0019 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x001A000C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230034 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000F0019 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x001A000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000F0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000F0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00260028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x0029002A +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00220028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x24252525 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x221C1A22 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000021 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x1F231F1E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x1D23191C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000001A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x2B2A2C2B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x25282B18 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000026 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x141F211F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x1B1B150F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x1C241F23 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x1D231E1F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000022 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x1F1C1D1F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1F1D1E1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000001C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x32323330 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x2C2F292C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000002A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x24231B1E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x211D221A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000001D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x040A0A0A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x06000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x090E070E +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x070C0008 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0A0A0D10 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x08090A00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x01090D0A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x0A070200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03060409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x05000408 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x00040004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x0A050505 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x06030105 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x09060107 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x09040503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x22202526 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x22271F22 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00190019 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000F000F +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x001A001A +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000019 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000818 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000405DC +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C08 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/3033_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/3033_emc.txt new file mode 100644 index 00000000..a0046e90 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/3033_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000B6 +EMC_RFC_0 = 0x00000352 +EMC_RAS_0 = 0x0000007F +EMC_RP_0 = 0x00000037 +EMC_R2W_0 = 0x00000034 +EMC_W2R_0 = 0x00000032 +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000037 +EMC_WR_RCD_0 = 0x00000037 +EMC_RRD_0 = 0x00000017 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002F +EMC_QRST_0 = 0x00080006 +EMC_QSAFE_0 = 0x00000042 +EMC_RDV_0 = 0x00000048 +EMC_REFRESH_0 = 0x00002DF5 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000020 +EMC_PDEX2RD_0 = 0x00000020 +EMC_PCHG2PDEN_0 = 0x00000006 +EMC_ACT2PDEN_0 = 0x0000002B +EMC_AR2PDEN_0 = 0x00000006 +EMC_RW2PDEN_0 = 0x00000049 +EMC_TXSR_0 = 0x00000368 +EMC_TCKE_0 = 0x00000019 +EMC_TFAW_0 = 0x0000005B +EMC_TRPAB_0 = 0x0000003F +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002E35 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x00000059 +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02F7002B +EMC_MRS_WAIT_CNT_0 = 0x07FF003C +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80120C22 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000004 +EMC_CKE2PDEN_0 = 0x0000001A +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000010 +EMC_EINPUT_DURATION_0 = 0x0000002F +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002E +EMC_TPD_0 = 0x00000017 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000004A +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000048 +EMC_RDV_EARLY_0 = 0x00000046 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862F7 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000048 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000B7D +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005B1E +EMC_TXSRDLL_0 = 0x00000368 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000003A +EMC_TR_RDV_MASK_0 = 0x0000004A +EMC_TR_QSAFE_0 = 0x00000042 +EMC_TR_QRST_0 = 0x00080006 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E00310 +EMC_IBDLY_0 = 0x10000025 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000A +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C08 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000003A +EMC_QUSE_WIDTH_0 = 0x0000000C +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x000001A9 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x000F0019 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x001B000C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x00200027 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x00230026 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230034 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x000F0019 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x001B000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x00080000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000F0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00260028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x0029002A +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00210027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00230028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x25262627 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x231D1B23 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000022 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x20232020 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x1F241B1D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000001B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x2C2B2D2C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x272A2C19 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000027 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x15202220 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x1D1C1611 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x0000001A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x1E252225 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x2C2F2C2D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000024 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x201E1F21 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x2C2C2D2A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000001D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x37373735 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x2E302B2E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000002C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x25251D1F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x221E231B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000001D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x0409090A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x05000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x090E060E +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x070C0008 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x0A0A0D0F +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x09090B00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000007 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00090D09 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x0A070200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x0008050A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x0407040A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x05000307 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01040103 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x08040603 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04040005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x0A050109 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x09040704 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x22202526 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x20232122 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x00190019 +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x000F000F +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00060006 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x000E000E +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x00000019 +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x0000080D +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000405ED +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C08 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/3066_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/3066_emc.txt new file mode 100644 index 00000000..6eea40ce --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/3066_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000B7 +EMC_RFC_0 = 0x0000035B +EMC_RAS_0 = 0x0000007F +EMC_RP_0 = 0x00000038 +EMC_R2W_0 = 0x00000034 +EMC_W2R_0 = 0x00000032 +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000038 +EMC_WR_RCD_0 = 0x00000038 +EMC_RRD_0 = 0x00000017 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002F +EMC_QRST_0 = 0x00080006 +EMC_QSAFE_0 = 0x00000042 +EMC_RDV_0 = 0x00000048 +EMC_REFRESH_0 = 0x00002E75 +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000020 +EMC_PDEX2RD_0 = 0x00000020 +EMC_PCHG2PDEN_0 = 0x00000006 +EMC_ACT2PDEN_0 = 0x0000002B +EMC_AR2PDEN_0 = 0x00000006 +EMC_RW2PDEN_0 = 0x00000049 +EMC_TXSR_0 = 0x00000372 +EMC_TCKE_0 = 0x00000019 +EMC_TFAW_0 = 0x0000005C +EMC_TRPAB_0 = 0x0000003F +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002EB5 +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000005A +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x02FF002B +EMC_MRS_WAIT_CNT_0 = 0x07FF003C +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012162B +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000004 +EMC_CKE2PDEN_0 = 0x0000001B +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000010 +EMC_EINPUT_DURATION_0 = 0x0000002F +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002E +EMC_TPD_0 = 0x00000017 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000004A +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000048 +EMC_RDV_EARLY_0 = 0x00000046 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x011862FF +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000039 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000B9D +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005C19 +EMC_TXSRDLL_0 = 0x00000372 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000003A +EMC_TR_RDV_MASK_0 = 0x0000004A +EMC_TR_QSAFE_0 = 0x00000042 +EMC_TR_QRST_0 = 0x00080006 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E00310 +EMC_IBDLY_0 = 0x10000025 +EMC_OBDLY_0 = 0x10000004 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000003A +EMC_QUSE_WIDTH_0 = 0x0000000C +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x000000E0 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000012 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A01A010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x00100019 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x001B000C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x0022002A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x00100019 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x001B000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x00000006 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000F0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000C +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000A +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000015 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x00020007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000F0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00250029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x0029002A +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220024 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00230027 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x26262626 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x221A1922 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000023 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x21242121 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x1D24191B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x29292929 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x27282919 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000027 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x121E211F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x1C1C1410 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000019 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x1F252325 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x1F272021 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000023 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x211F1F21 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1F1E211D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000001E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x34353530 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x2B30282B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000032 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x2526191C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x211D2219 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000001B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x080B0B0C +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x03000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x0A0E060E +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x070D0009 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x090A0C12 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x09090B00 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000008 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x01060707 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x0A090200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x0004020A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02060406 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02000102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01010001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x08040503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04030004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x0A060208 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x0A050706 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x23232427 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x20252121 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x00080008 +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000C000C +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x001B001B +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x0000000D +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000819 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x000405FD +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/3100_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/3100_emc.txt new file mode 100644 index 00000000..c6d1e814 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/3100_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000B7 +EMC_RFC_0 = 0x00000364 +EMC_RAS_0 = 0x0000007F +EMC_RP_0 = 0x00000038 +EMC_R2W_0 = 0x00000035 +EMC_W2R_0 = 0x00000032 +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000038 +EMC_WR_RCD_0 = 0x00000038 +EMC_RRD_0 = 0x00000018 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002F +EMC_QRST_0 = 0x00080006 +EMC_QSAFE_0 = 0x00000042 +EMC_RDV_0 = 0x00000048 +EMC_REFRESH_0 = 0x00002EFA +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000021 +EMC_PDEX2RD_0 = 0x00000021 +EMC_PCHG2PDEN_0 = 0x00000006 +EMC_ACT2PDEN_0 = 0x0000002C +EMC_AR2PDEN_0 = 0x00000006 +EMC_RW2PDEN_0 = 0x00000049 +EMC_TXSR_0 = 0x0000037C +EMC_TCKE_0 = 0x0000001A +EMC_TFAW_0 = 0x0000005D +EMC_TRPAB_0 = 0x0000003F +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002F3A +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000005B +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x0307002C +EMC_MRS_WAIT_CNT_0 = 0x07FF003C +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x80122F44 +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000004 +EMC_CKE2PDEN_0 = 0x0000001B +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D00D0 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x00000010 +EMC_EINPUT_DURATION_0 = 0x0000002F +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002F +EMC_TPD_0 = 0x00000018 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x0011083D +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000004A +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000048 +EMC_RDV_EARLY_0 = 0x00000046 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186307 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000048 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000BBE +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005D1C +EMC_TXSRDLL_0 = 0x0000037C +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000003A +EMC_TR_RDV_MASK_0 = 0x0000004A +EMC_TR_QSAFE_0 = 0x00000042 +EMC_TR_QRST_0 = 0x00080006 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E00310 +EMC_IBDLY_0 = 0x1000001C +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0C09 +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000002B +EMC_QUSE_WIDTH_0 = 0x0000000C +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000249 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x000001B2 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000012 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A012018 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x0010001A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x001B000D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0025002B +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00230035 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x0010001A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x001B000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000016 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x000F0000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000016 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x000F0000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00250028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x0028002A +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00210028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x25262526 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x251F1A25 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x0000002D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x2C2E2D2C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x2B2E292A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000029 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x2E2B2E2E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x30323329 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000026 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x252C2D2C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x2B2A2623 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000018 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x2C2F2E2F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x2D2F2C2D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x0000002E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x2D2C2D2D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x2C2C2D2A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000001A +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x32353531 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x2F32292E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000002B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x26251B1D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x211E2418 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000002B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x040B0B0B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x03000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x0A0E060E +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x04050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x06050709 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x06060700 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00040505 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x08070000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00090509 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x02050306 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000005 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x02000102 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x07040503 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04040004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x07050105 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x03020200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x22222426 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x27252325 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x00100010 +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x00060006 +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x001B001B +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x0000000D +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00000000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1E191E19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x00000819 +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040320 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000C09 +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/3133_emc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/3133_emc.txt new file mode 100644 index 00000000..f96b4775 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/emc/3133_emc.txt @@ -0,0 +1,528 @@ +Dumping EMC registers from BASE=0x7001B000 +----------------------------------- +EMC_INTSTATUS_0 = 0x00000030 +EMC_INTMASK_0 = 0x00000000 +EMC_DBG_0 = 0x01000C00 +EMC_CFG_0 = 0xF3200000 +EMC_ADR_CFG_0 = 0x00000000 +EMC_REFCTRL_0 = 0x80000002 +EMC_PIN_0 = 0x00003101 +EMC_TIMING_CONTROL_0 = 0x00000001 +EMC_RC_0 = 0x000000B8 +EMC_RFC_0 = 0x0000036E +EMC_RAS_0 = 0x0000007F +EMC_RP_0 = 0x00000039 +EMC_R2W_0 = 0x00000035 +EMC_W2R_0 = 0x00000033 +EMC_R2P_0 = 0x00000010 +EMC_W2P_0 = 0x0000003B +EMC_RD_RCD_0 = 0x00000039 +EMC_WR_RCD_0 = 0x00000039 +EMC_RRD_0 = 0x00000018 +EMC_REXT_0 = 0x0000001D +EMC_WDV_0 = 0x00000012 +EMC_QUSE_0 = 0x0000002F +EMC_QRST_0 = 0x00080005 +EMC_QSAFE_0 = 0x00000044 +EMC_RDV_0 = 0x00000049 +EMC_REFRESH_0 = 0x00002F7B +EMC_BURST_REFRESH_NUM_0 = 0x00000000 +EMC_PDEX2WR_0 = 0x00000021 +EMC_PDEX2RD_0 = 0x00000021 +EMC_PCHG2PDEN_0 = 0x00000006 +EMC_ACT2PDEN_0 = 0x0000002C +EMC_AR2PDEN_0 = 0x00000006 +EMC_RW2PDEN_0 = 0x00000049 +EMC_TXSR_0 = 0x00000385 +EMC_TCKE_0 = 0x0000001A +EMC_TFAW_0 = 0x0000005E +EMC_TRPAB_0 = 0x0000003F +EMC_TCLKSTABLE_0 = 0x00000004 +EMC_TCLKSTOP_0 = 0x0000001F +EMC_TREFBW_0 = 0x00002FBB +EMC_TPPD_0 = 0x00000004 +EMC_ODT_WRITE_0 = 0x00000000 +EMC_PDEX2MRR_0 = 0x0000005C +EMC_WEXT_0 = 0x00000019 +EMC_RFC_SLR_0 = 0x00000000 +EMC_MRS_WAIT_CNT2_0 = 0x0310002C +EMC_MRS_WAIT_CNT_0 = 0x07FF003C +EMC_MRS_0 = 0x00000000 +EMC_EMRS_0 = 0x00000000 +EMC_REF_0 = 0x80000000 +EMC_PRE_0 = 0x00000000 +EMC_NOP_0 = 0x00000000 +EMC_SELF_REF_0 = 0x00000000 +EMC_DPD_0 = 0x00000000 +EMC_MRW_0 = 0x00170040 +EMC_MRR_0 = 0x8012364C +EMC_CMDQ_0 = 0x10004408 +EMC_MC2EMCQ_0 = 0x06000404 +EMC_FBIO_SPARE_0 = 0x00000012 +EMC_FBIO_CFG5_0 = 0x9160A00D +EMC_FBIO_CFG6_0 = 0x00001010 +EMC_PDEX2CKE_0 = 0x00000004 +EMC_CKE2PDEN_0 = 0x0000001B +EMC_CFG_RSV_0 = 0xFF00FF00 +EMC_ACPD_CONTROL_0 = 0x00000000 +EMC_MPC_0 = 0x0000004B +EMC_EMRS2_0 = 0x00000000 +EMC_EMRS3_0 = 0x00000000 +EMC_MRW2_0 = 0x8802003F +EMC_MRW3_0 = 0x8C0D0010 +EMC_MRW4_0 = 0xC0000000 +EMC_CLKEN_OVERRIDE_0 = 0x00000000 +EMC_R2R_0 = 0x00000000 +EMC_W2W_0 = 0x00000000 +EMC_EINPUT_0 = 0x0000000F +EMC_EINPUT_DURATION_0 = 0x00000031 +EMC_PUTERM_EXTRA_0 = 0x00000001 +EMC_TCKESR_0 = 0x0000002F +EMC_TPD_0 = 0x00000018 +EMC_AUTO_CAL_CONFIG_0 = 0x201A51D8 +EMC_AUTO_CAL_INTERVAL_0 = 0x001FFFFF +EMC_AUTO_CAL_STATUS_0 = 0x1D190000 +EMC_REQ_CTRL_0 = 0x00000000 +EMC_EMC_STATUS_0 = 0x0B430035 +EMC_CFG_2_0 = 0x00110835 +EMC_CFG_DIG_DLL_0 = 0x002C03A9 +EMC_CFG_DIG_DLL_PERIOD_0 = 0x00008000 +EMC_DIG_DLL_STATUS_0 = 0x00000004 +EMC_CFG_DIG_DLL_1_0 = 0x000F3701 +EMC_RDV_MASK_0 = 0x0000004B +EMC_WDV_MASK_0 = 0x00000012 +EMC_RDV_EARLY_MASK_0 = 0x00000049 +EMC_RDV_EARLY_0 = 0x00000047 +EMC_AUTO_CAL_CONFIG8_0 = 0x00880000 +EMC_ZCAL_INTERVAL_0 = 0x00064000 +EMC_ZCAL_WAIT_CNT_0 = 0x003F07FF +EMC_ZCAL_MRW_CMD_0 = 0x8051004F +EMC_ZQ_CAL_0 = 0x80000002 +EMC_XM2COMPPADCTRL3_0 = 0x00901000 +EMC_AUTO_CAL_VREF_SEL_0_0 = 0xC9AFBCBC +EMC_AUTO_CAL_VREF_SEL_1_0 = 0x00009E3C +EMC_XM2COMPPADCTRL_0 = 0x00000030 +EMC_FDPD_CTRL_DQ_0 = 0x8020221F +EMC_FDPD_CTRL_CMD_0 = 0x0220F40F +EMC_PMACRO_CMD_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_PMACRO_DATA_BRICK_CTRL_FDPD_0 = 0x00000000 +EMC_SCRATCH0_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU1_0 = 0x00000000 +EMC_PMACRO_BRICK_CTRL_RFU2_0 = 0x00000000 +EMC_CMD_MAPPING_CMD0_0_0 = 0x061B0504 +EMC_CMD_MAPPING_CMD0_1_0 = 0x1C070302 +EMC_CMD_MAPPING_CMD0_2_0 = 0x05252523 +EMC_CMD_MAPPING_CMD1_0_0 = 0x0A091D08 +EMC_CMD_MAPPING_CMD1_1_0 = 0x0D1E0B24 +EMC_CMD_MAPPING_CMD1_2_0 = 0x0326260C +EMC_CMD_MAPPING_CMD2_0_0 = 0x231C1B02 +EMC_CMD_MAPPING_CMD2_1_0 = 0x05070403 +EMC_CMD_MAPPING_CMD2_2_0 = 0x02252506 +EMC_CMD_MAPPING_CMD3_0_0 = 0x0D1D0B0A +EMC_CMD_MAPPING_CMD3_1_0 = 0x1E090C08 +EMC_CMD_MAPPING_CMD3_2_0 = 0x08262624 +EMC_CMD_MAPPING_BYTE_0 = 0x9A070624 +EMC_TR_TIMING_0_0 = 0x01186310 +EMC_TR_CTRL_0_0 = 0x00000020 +EMC_TR_CTRL_1_0 = 0x00000000 +EMC_SWITCH_BACK_CTRL_0 = 0x00000001 +EMC_TR_RDV_0 = 0x00000049 +EMC_STALL_THEN_EXE_BEFORE_CLKCHANGE_0 = 0x00000000 +EMC_STALL_THEN_EXE_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_UNSTALL_RW_AFTER_CLKCHANGE_0 = 0x00000000 +EMC_AUTO_CAL_ = 0x3F1F080B +EMC_SEL_DPD_CTRL_0 = 0x0004000C +EMC_PRE_REFRESH_REQ_CNT_0 = 0x00000BDE +EMC_DYN_SELF_REF_CONTROL_0 = 0x80005E17 +EMC_TXSRDLL_0 = 0x00000385 +EMC_CCFIFO_ADDR_0 = 0x80000000 +EMC_CCFIFO_DATA_0 = 0x00000000 +EMC_CCFIFO_STATUS_0 = 0x00000000 +EMC_TR_QPOP_0 = 0x0000003B +EMC_TR_RDV_MASK_0 = 0x0000004B +EMC_TR_QSAFE_0 = 0x00000044 +EMC_TR_QRST_0 = 0x00080005 +EMC_SWIZZLE_RANK0_BYTE0_0 = 0x76543201 +EMC_SWIZZLE_RANK0_BYTE1_0 = 0x65324710 +EMC_SWIZZLE_RANK0_BYTE2_0 = 0x25763410 +EMC_SWIZZLE_RANK0_BYTE3_0 = 0x25673401 +EMC_SWIZZLE_RANK1_BYTE0_0 = 0x32647501 +EMC_SWIZZLE_RANK1_BYTE1_0 = 0x34567201 +EMC_SWIZZLE_RANK1_BYTE2_0 = 0x56742310 +EMC_SWIZZLE_RANK1_BYTE3_0 = 0x67324501 +EMC_ISSUE_QRST_0 = 0x00000000 +EMC_PMC_SCRATCH1_0 = 0x4FAF9FFF +EMC_PMC_SCRATCH2_0 = 0x7FFFFFFF +EMC_PMC_SCRATCH3_0 = 0x4036D71F +EMC_AUTO_CAL_CONFIG2_0 = 0x05500000 +EMC_AUTO_CAL_CONFIG3_0 = 0x00880000 +EMC_TR_DVFS_0 = 0x00000000 +EMC_AUTO_CAL_CHANNEL_0 = 0xC1E00310 +EMC_IBDLY_0 = 0x1000001C +EMC_OBDLY_0 = 0x10000002 +EMC_TXDSRVTTGEN_0 = 0x00000000 +EMC_WE_DURATION_0 = 0x0000000E +EMC_WS_DURATION_0 = 0x00000008 +EMC_WEV_0 = 0x0000000E +EMC_WSV_0 = 0x00000010 +EMC_CFG_3_0 = 0x00000040 +EMC_MRW5_0 = 0x00000000 +EMC_MRW6_0 = 0x8803F1F1 +EMC_MRW7_0 = 0xC803F1F1 +EMC_MRW8_0 = 0x880B0606 +EMC_MRW9_0 = 0x8C0E5D5D +EMC_MRW10_0 = 0x880C5D5D +EMC_MRW11_0 = 0xC80C5D5D +EMC_MRW12_0 = 0x880E0E0B +EMC_MRW13_0 = 0xC80E0000 +EMC_MRW14_0 = 0x88161414 +EMC_MRW15_0 = 0xC8161414 +EMC_CFG_SYNC_0 = 0x00000001 +EMC_FDPD_CTRL_CMD_NO_RAMP_0 = 0x00000001 +EMC_WDV_CHK_0 = 0x00000006 +EMC_CFG_PIPE_2_0 = 0x00000000 +EMC_CFG_PIPE_CLK_0 = 0x00000000 +EMC_CFG_PIPE_1_0 = 0x0FFF0000 +EMC_CFG_PIPE_0 = 0x0FFF0000 +EMC_QPOP_0 = 0x0000003B +EMC_QUSE_WIDTH_0 = 0x0000000D +EMC_PUTERM_WIDTH_0 = 0x80000000 +EMC_BGBIAS_CTL0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG7_0 = 0x00880000 +EMC_XM2COMPPADCTRL2_0 = 0x16001000 +EMC_COMP_PAD_SW_CTRL_0 = 0x738000F0 +EMC_REFCTRL2_0 = 0x00000000 +EMC_FBIO_CFG7_0 = 0x00003BFF +EMC_DATA_BRLSHFT_0_0 = 0x00000492 +EMC_DATA_BRLSHFT_1_0 = 0x00000000 +EMC_RFCPB_0 = 0x000001B7 +EMC_DQS_BRLSHFT_0_0 = 0x00000000 +EMC_DQS_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_0_0 = 0x00000000 +EMC_CMD_BRLSHFT_1_0 = 0x00000000 +EMC_CMD_BRLSHFT_2_0 = 0x00000024 +EMC_CMD_BRLSHFT_3_0 = 0x00000024 +EMC_QUSE_BRLSHFT_0_0 = 0x00000000 +EMC_AUTO_CAL_CONFIG4_0 = 0x00880000 +EMC_AUTO_CAL_CONFIG5_0 = 0x00001220 +EMC_QUSE_BRLSHFT_1_0 = 0x00000000 +EMC_QUSE_BRLSHFT_2_0 = 0x00000000 +EMC_CCDMW_0 = 0x00000020 +EMC_QUSE_BRLSHFT_3_0 = 0x00000000 +EMC_FBIO_CFG8_0 = 0x0CF30000 +EMC_AUTO_CAL_CONFIG6_0 = 0x00880000 +EMC_PROTOBIST_CONFIG_ADR_1_0 = 0x30000000 +EMC_PROTOBIST_CONFIG_ADR_2_0 = 0x08000101 +EMC_PROTOBIST_MISC_0 = 0x00000000 +EMC_PROTOBIST_WDATA_LOWER_0 = 0x2A01A010 +EMC_PROTOBIST_WDATA_UPPER_0 = 0xC8200002 +EMC_PROTOBIST_RDATA_0 = 0x00000000 +EMC_DLL_CFG_0_0 = 0x1F136120 +EMC_DLL_CFG_1_0 = 0x00012014 +EMC_CONFIG_SAMPLE_DELAY_0 = 0x00000020 +EMC_CFG_UPDATE_0 = 0x70000301 +EMC_PMACRO_QUSE_DDLL_RANK0_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK0_5_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_0_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_1_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_2_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_3_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_4_0 = 0x00000000 +EMC_PMACRO_QUSE_DDLL_RANK1_5_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4_0 = 0x0010001A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5_0 = 0x001C000D +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_0 = 0x0022002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_0 = 0x0020002E +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_0 = 0x0026002C +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_0 = 0x00240035 +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4_0 = 0x0010001A +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5_0 = 0x001C000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3_0 = 0x00000016 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5_0 = 0x00080000 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0_0 = 0x0000000D +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1_0 = 0x0000000B +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2_0 = 0x00000007 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3_0 = 0x00000016 +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4_0 = 0x0004000E +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5_0 = 0x00100000 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0_0 = 0x00230029 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1_0 = 0x0028002A +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2_0 = 0x00220026 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3_0 = 0x00200028 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_5_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_4_0 = 0x00200020 +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_5_0 = 0x00200020 +EMC_PMACRO_AUTOCAL_CFG_0_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_1_0 = 0x04040404 +EMC_PMACRO_AUTOCAL_CFG_2_0 = 0x04040404 +EMC_PMACRO_TX_PWRD_0_0 = 0x10000000 +EMC_PMACRO_TX_PWRD_1_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_2_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_3_0 = 0x00000000 +EMC_PMACRO_TX_PWRD_4_0 = 0x00400080 +EMC_PMACRO_TX_PWRD_5_0 = 0x00801004 +EMC_PMACRO_TX_SEL_CLK_SRC_0_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_1_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_2_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_3_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_4_0 = 0x00000000 +EMC_PMACRO_TX_SEL_CLK_SRC_5_0 = 0x00000000 +EMC_PMACRO_DDLL_BYPASS_0 = 0xEF000000 +EMC_PMACRO_DDLL_PWRD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_PWRD_2_0 = 0x1C1C1C1C +EMC_PMACRO_CMD_CTRL_0_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_1_0 = 0x00000000 +EMC_PMACRO_CMD_CTRL_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x24242424 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x231E1C23 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000023 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x23242321 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x20241A1D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x0000001C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x28282A29 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x28282919 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000028 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x121C1F1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x1A1A150D +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000018 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x1D252022 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x1D221F1F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000021 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x1F1E1E20 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x1E1D1E1C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x0000001C +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x32323232 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x3232292E +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x0000002B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x22231B1F +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x21202217 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x0000001B +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0_0 = 0x060A0A0A +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1_0 = 0x07010008 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0_0 = 0x05050305 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1_0 = 0x03050004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0_0 = 0x08080C11 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1_0 = 0x06070700 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2_0 = 0x00000006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0_0 = 0x00080E08 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1_0 = 0x08070200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2_0 = 0x00000002 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0_0 = 0x00070308 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1_0 = 0x03060409 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2_0 = 0x00000004 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0_0 = 0x0600030B +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1_0 = 0x01030105 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2_0 = 0x00000003 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0_0 = 0x03020302 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1_0 = 0x04020006 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0_0 = 0x04050103 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1_0 = 0x04040200 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2_0 = 0x00000001 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD0_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD1_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD2_2_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_0_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_1_0 = 0x00000000 +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_CMD3_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQ_0_0 = 0x24202125 +EMC_PMACRO_IB_VREF_DQ_1_0 = 0x27241D22 +EMC_PMACRO_IB_VREF_DQ_2_0 = 0x00000000 +EMC_PMACRO_IB_VREF_DQS_0_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_1_0 = 0x29292929 +EMC_PMACRO_IB_VREF_DQS_2_0 = 0x00000000 +EMC_PMACRO_DDLL_LONG_CMD_0_0 = 0x001A001A +EMC_PMACRO_DDLL_LONG_CMD_1_0 = 0x00080008 +EMC_PMACRO_DDLL_LONG_CMD_2_0 = 0x000D000D +EMC_PMACRO_DDLL_LONG_CMD_3_0 = 0x000E000E +EMC_PMACRO_DDLL_LONG_CMD_4_0 = 0x0000001A +EMC_PMACRO_DDLL_LONG_CMD_5_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_0_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_1_0 = 0x00000000 +EMC_PMACRO_DDLL_SHORT_CMD_2_0 = 0x00000000 +EMC_PMACRO_CFG_PM_GLOBAL_0_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_0_0 = 0x00090000 +EMC_PMACRO_VTTGEN_CTRL_1_0 = 0x00102000 +EMC_PMACRO_BG_BIAS_CTRL_0_0 = 0x00001000 +EMC_PMACRO_PAD_CFG_CTRL_0 = 0x00000000 +EMC_PMACRO_ZCTRL_0 = 0x00505050 +EMC_PMACRO_RX_TERM_0 = 0x080B080B +EMC_PMACRO_CMD_TX_DRV_0 = 0x00001220 +EMC_PMACRO_CMD_PAD_RX_CTRL_0 = 0x06000000 +EMC_PMACRO_DATA_PAD_RX_CTRL_0 = 0x06060000 +EMC_PMACRO_CMD_RX_TERM_MODE_0 = 0x00002000 +EMC_PMACRO_DATA_RX_TERM_MODE_0 = 0x00000211 +EMC_PMACRO_CMD_PAD_TX_CTRL_0 = 0x40021084 +EMC_PMACRO_DATA_PAD_TX_CTRL_0 = 0x40021485 +EMC_PMACRO_COMMON_PAD_TX_CTRL_0 = 0x00000000 +EMC_PMACRO_DQ_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_CA_TX_DRV_0 = 0x1D191D19 +EMC_PMACRO_AUTOCAL_CFG_COMMON_0 = 0x0000081A +EMC_PMACRO_DDLLCAL_CAL_0 = 0x00000000 +EMC_PMACRO_DDLL_OFFSET_0 = 0x00000000 +EMC_PMACRO_DDLL_PERIODIC_OFFSET_0 = 0x00000000 +EMC_PMACRO_VTTGEN_CTRL_2_0 = 0x00000000 +EMC_PMACRO_IB_RXRT_0 = 0x00000078 +EMC_PMACRO_TRAINING_CTRL_0_0 = 0x00000008 +EMC_PMACRO_TRAINING_CTRL_1_0 = 0x00000008 +EMC_TRAINING_CMD_0 = 0x000000CC +EMC_TRAINING_CTRL_0 = 0x00009080 +EMC_TRAINING_STATUS_0 = 0x00000000 +EMC_TRAINING_QUSE_CORS_CTRL_0 = 0x01124000 +EMC_TRAINING_QUSE_FINE_CTRL_0 = 0x01125B6A +EMC_TRAINING_QUSE_CTRL_MISC_0 = 0x0F081000 +EMC_TRAINING_WRITE_FINE_CTRL_0 = 0x1114FC00 +EMC_TRAINING_WRITE_CTRL_MISC_0 = 0x07004300 +EMC_TRAINING_WRITE_VREF_CTRL_0 = 0x00102306 +EMC_TRAINING_READ_FINE_CTRL_0 = 0x1110FC00 +EMC_TRAINING_READ_CTRL_MISC_0 = 0x0F085300 +EMC_TRAINING_READ_VREF_CTRL_0 = 0x00104210 +EMC_TRAINING_CA_FINE_CTRL_0 = 0x0513801F +EMC_TRAINING_CA_CTRL_MISC_0 = 0x1F101100 +EMC_TRAINING_CA_CTRL_MISC1_0 = 0x00000014 +EMC_TRAINING_CA_VREF_CTRL_0 = 0x00107240 +EMC_TRAINING_CA_TADR_CTRL_0 = 0x00028000 +EMC_TRAINING_SETTLE_0 = 0x07070404 +EMC_TRAINING_DEBUG_CTRL_0 = 0x00000000 +EMC_TRAINING_MPC_0 = 0x00000000 +EMC_TRAINING_PATRAM_CTRL_0 = 0x800000FF +EMC_TRAINING_PATRAM_DQ_0 = 0x0F0F0F0F +EMC_TRAINING_PATRAM_DMI_0 = 0x00000000 +EMC_TRAINING_VREF_SETTLE_0 = 0x00040320 +EMC_TRAINING_OPT_CA_VREF_0 = 0x00000000 +EMC_TRAINING_OPT_DQ_OB_VREF_0 = 0x00000E0B +EMC_TRAINING_QUSE_VREF_CTRL_0 = 0x00105800 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2133_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2133_mc.txt new file mode 100644 index 00000000..a7aa0fff --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2133_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFC9B +MC_SMMU_PTC_FLUSH_0 = 0x77E6A271 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000010 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000008 +MC_EMEM_ARB_TIMING_RP_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RC_0 = 0x00000020 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000015 +MC_EMEM_ARB_TIMING_FAW_0 = 0x0000000F +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000003 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00110B10 +MC_EMEM_ARB_MISC0_0 = 0x72703021 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630B0 +MC_ERR_SEC_ADR_0 = 0x02930810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000004A +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00600004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00600038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00600005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00600014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00600060 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00600016 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00600095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00600041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00600080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0060003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00600013 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000060 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00600090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00600004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000060 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080011 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00600013 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00600005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00600018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2166_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2166_mc.txt new file mode 100644 index 00000000..614a37d3 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2166_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000F7B9B +MC_SMMU_PTC_FLUSH_0 = 0x58681E41 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000010 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80030080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000008 +MC_EMEM_ARB_TIMING_RP_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RC_0 = 0x00000020 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000015 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000010 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00110B10 +MC_EMEM_ARB_MISC0_0 = 0x72713121 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80040080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x00001020 +MC_ERR_SEC_ADR_0 = 0x02000000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000004B +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x005E0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x005E0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x005E0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x005E0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x005E005E +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x005E0015 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x005E0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x005E0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x005E0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x005E003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x005E0013 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000005E +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x005E0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x005E0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000005E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080010 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x005E0013 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x005E0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x005E0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2200_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2200_mc.txt new file mode 100644 index 00000000..01d3bc9c --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2200_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD4B +MC_SMMU_PTC_FLUSH_0 = 0x77D4C531 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x08000010 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000008 +MC_EMEM_ARB_TIMING_RP_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RC_0 = 0x00000021 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000016 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000010 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00120B10 +MC_EMEM_ARB_MISC0_0 = 0x72713222 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x00040041 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80020080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02110000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000004C +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x005D0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x005D0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x005D0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x005D0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x005D005D +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x005D0015 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x005D0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x005D0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x005D0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x005D003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x005D0012 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000005D +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x005D0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x005D0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000005D +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080010 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x005D0012 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x005D0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x005D0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2233_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2233_mc.txt new file mode 100644 index 00000000..b0b63691 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2233_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x01211200 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFBDB +MC_SMMU_PTC_FLUSH_0 = 0x7981FF41 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000010 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80010080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000021 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000016 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000010 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00120B10 +MC_EMEM_ARB_MISC0_0 = 0x72713322 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x001E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x003E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000010F0 +MC_ERR_SEC_ADR_0 = 0x02123000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000004E +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x005B0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x005B0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x005B0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x005B0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x005B005B +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x005B0015 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x005B0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x005B0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x005B0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x005B003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x005B0012 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000005B +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x005B0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x005B0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000005B +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080010 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x005B0012 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x005B0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x005B0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2266_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2266_mc.txt new file mode 100644 index 00000000..02d482ad --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2266_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x01011200 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FF37F +MC_SMMU_PTC_FLUSH_0 = 0x4AF0EDF1 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000011 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000022 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000016 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000010 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00120B11 +MC_EMEM_ARB_MISC0_0 = 0x72713323 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x00040041 +MC_ERR_VPR_ADR_0 = 0x0C1D1020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80020080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000010F0 +MC_ERR_SEC_ADR_0 = 0x02013000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000004F +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000445 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x005A0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x005A0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x005A0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x005A0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x005A005A +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x005A0014 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x005A0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x005A0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x005A0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x005A003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x005A0012 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000005A +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x005A0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x005A0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000005A +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x00080010 +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x005A0012 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x005A0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x005A0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2300_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2300_mc.txt new file mode 100644 index 00000000..ec446205 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2300_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCFB +MC_SMMU_PTC_FLUSH_0 = 0x7ABA83D1 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000011 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000022 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000017 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000011 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00120C11 +MC_EMEM_ARB_MISC0_0 = 0x72723423 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C1D1020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000010E0 +MC_ERR_SEC_ADR_0 = 0x02022000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000050 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00590004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00590038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00590005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00590014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00590059 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00590014 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00590095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00590041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00590080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0059003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00590012 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000059 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00590090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00590004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000059 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000F +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00590012 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00590005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00590018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2333_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2333_mc.txt new file mode 100644 index 00000000..2c5683c1 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2333_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD4B +MC_SMMU_PTC_FLUSH_0 = 0x7ABA6511 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x08000011 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80010080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000022 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000017 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000011 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00120C11 +MC_EMEM_ARB_MISC0_0 = 0x72723523 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80030080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02132810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000051 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00570004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00570038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00570005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00570014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00570057 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00570014 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00570095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00570041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00570080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0057003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00570011 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000057 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00570090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00570004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000057 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000F +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00570011 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00570005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00570018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2366_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2366_mc.txt new file mode 100644 index 00000000..79067de6 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2366_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCDB +MC_SMMU_PTC_FLUSH_0 = 0x78694471 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000011 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000023 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000017 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000011 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000A +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00120C11 +MC_EMEM_ARB_MISC0_0 = 0x72723624 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C1D1020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80080080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02130810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000052 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00560004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00560038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00560005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00560014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00560056 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00560013 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00560095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00560041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00560080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0056003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00560011 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000056 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00560090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00560004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000056 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000F +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00560011 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00560005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00560018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2400_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2400_mc.txt new file mode 100644 index 00000000..a29ae6a3 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2400_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD7B +MC_SMMU_PTC_FLUSH_0 = 0x77CE85E1 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000012 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80060080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000024 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000018 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000011 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00130C12 +MC_EMEM_ARB_MISC0_0 = 0x72723625 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x00000040 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80020080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02130010 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000053 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00550004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00550038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00550005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00550014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00550055 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00550013 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00550095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00550041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00550080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0055003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00550011 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000055 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00550090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00550004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000055 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000F +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00550011 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00550005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00550018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2433_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2433_mc.txt new file mode 100644 index 00000000..8c34b512 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2433_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD5B +MC_SMMU_PTC_FLUSH_0 = 0x77E80541 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000012 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80010080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x00000009 +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RC_0 = 0x00000024 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000018 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000012 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00130C12 +MC_EMEM_ARB_MISC0_0 = 0x72733725 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x00000041 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000610F0 +MC_ERR_SEC_ADR_0 = 0x02132000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000055 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00540004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00540038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00540005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00540014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00540054 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00540013 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00540095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00540041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00540080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0054003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00540011 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000054 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00540090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00540004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000054 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000F +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00540011 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00540005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00540018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2466_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2466_mc.txt new file mode 100644 index 00000000..e14ca84e --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2466_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD1B +MC_SMMU_PTC_FLUSH_0 = 0x77E49471 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x08000012 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000025 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000018 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000012 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00130C12 +MC_EMEM_ARB_MISC0_0 = 0x72733826 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x001E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x003E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02130810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000056 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00530004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00530038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00530005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00530014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00530053 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00530013 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00530095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00530041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00530080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0053003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00530010 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000080 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00530090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00530004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000053 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000E +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00530010 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00530005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00530018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2500_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2500_mc.txt new file mode 100644 index 00000000..4c25303c --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2500_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFC9B +MC_SMMU_PTC_FLUSH_0 = 0x77E6B271 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000012 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80030080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000025 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000019 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000012 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000C +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00130C12 +MC_EMEM_ARB_MISC0_0 = 0x72733926 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C1D1000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x00063070 +MC_ERR_SEC_ADR_0 = 0x02932800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000057 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00510004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00510038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00510005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00510014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00510051 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00510012 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00510095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00510041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00510080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0051003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00510010 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000051 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00510090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00510004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000051 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000E +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00510010 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00510005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00510018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2533_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2533_mc.txt new file mode 100644 index 00000000..46cad500 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2533_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFDAB +MC_SMMU_PTC_FLUSH_0 = 0x77E826A1 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000013 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000026 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000019 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000012 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00130D13 +MC_EMEM_ARB_MISC0_0 = 0x72733927 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x00023070 +MC_ERR_SEC_ADR_0 = 0x02130000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000058 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00500004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00500038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00500005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00500014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00500050 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00500012 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00500095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00500041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00500080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0050003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x00500010 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000050 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00500090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00500004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000050 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000E +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x00500010 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00500005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00500018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2566_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2566_mc.txt new file mode 100644 index 00000000..4d39b665 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2566_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD5B +MC_SMMU_PTC_FLUSH_0 = 0x77DD7551 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000013 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000026 +MC_EMEM_ARB_TIMING_RAS_0 = 0x00000019 +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000013 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00130D13 +MC_EMEM_ARB_MISC0_0 = 0x72743A27 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02930000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000059 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003F +MC_AUD_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003F +MC_USBD_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MAX_0 = 0x0000003F +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x0000003F +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x0000003F +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_MAX_0 = 0x0000003F +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003F +MC_RING2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003F +MC_MLL_MPCORER_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_MIN_0 = 0x0000003F +MC_RING1_PTSA_RATE_0 = 0x0000035C +MC_JPG_PTSA_MIN_0 = 0x0000003F +MC_HDAPC_PTSA_MIN_0 = 0x0000003F +MC_AVP_PTSA_MIN_0 = 0x0000003F +MC_JPG_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_MAX_0 = 0x0000003F +MC_SDM_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MIN_0 = 0x0000003F +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003F +MC_GK2_PTSA_MAX_0 = 0x0000003F +MC_AUD_PTSA_MAX_0 = 0x0000003F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x0000003F +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003F +MC_USBX_PTSA_MAX_0 = 0x0000003F +MC_DIS_PTSA_RATE_0 = 0x00000000 +MC_USBD_PTSA_MAX_0 = 0x0000003F +MC_A9AVPPC_PTSA_MAX_0 = 0x0000003F +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x0000003F +MC_HDAPC_PTSA_MAX_0 = 0x0000003F +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x0000003F +MC_RING2_PTSA_MIN_0 = 0x0000003F +MC_SDM_PTSA_MIN_0 = 0x0000003F +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MIN_0 = 0x0000003F +MC_SMMU_SMMU_PTSA_MIN_0 = 0x0000003F +MC_ISP_PTSA_MIN_0 = 0x0000003F +MC_HOST_PTSA_MAX_0 = 0x0000003F +MC_SAX_PTSA_MAX_0 = 0x0000003F +MC_VE_PTSA_MIN_0 = 0x0000003F +MC_GK_PTSA_MIN_0 = 0x0000003F +MC_MSE_PTSA_MAX_0 = 0x0000003F +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x004F0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x004F0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000018 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x004F0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x004F0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x004F004F +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x004F0012 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x004F0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x004F0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x004F0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x004F003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x0080009B +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x004F0010 +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000004F +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x004F0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x004F0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000004F +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00800065 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000E +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x004F0010 +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x004F0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x004F0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00800024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2600_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2600_mc.txt new file mode 100644 index 00000000..663ad8f0 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2600_mc.txt @@ -0,0 +1,56 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +mc_emem_arb_cfg = 0x08000013 +mc_emem_arb_outstanding_req = 0x80000080 +mc_emem_arb_timing_rcd = 0x0000000A +mc_emem_arb_timing_rp = 0x0000000B +mc_emem_arb_timing_rc = 0x00000027 +mc_emem_arb_timing_ras = 0x0000001A +mc_emem_arb_timing_faw = 0x00000013 +mc_emem_arb_timing_rrd = 0x00000004 +mc_emem_arb_timing_rap2pre = 0x00000004 +mc_emem_arb_timing_wap2pre = 0x00000011 +mc_emem_arb_timing_r2r = 0x00000001 +mc_emem_arb_timing_w2w = 0x00000001 +mc_emem_arb_timing_r2w = 0x0000000E +mc_emem_arb_timing_w2r = 0x0000000D +mc_emem_arb_da_turns = 0x06070000 +mc_emem_arb_da_covers = 0x00130D13 +mc_emem_arb_misc0 = 0x72743B28 +mc_emem_arb_misc1 = 0x70000F0F +mc_emem_arb_misc2 = 0x00000000 +mc_emem_arb_ring1_throttle = 0x001F0000 +mc_emem_arb_timing_rfcpb = 0x0000005A +mc_emem_arb_timing_ccdmw = 0x00000008 +mc_emem_arb_dhyst_ctrl = 0x000A1020 +mc_emem_arb_dhyst_timeout_util_0 = 0x0000001A +mc_emem_arb_dhyst_timeout_util_1 = 0x0000001A +mc_emem_arb_dhyst_timeout_util_2 = 0x0000001A +mc_emem_arb_dhyst_timeout_util_3 = 0x0000001A +mc_emem_arb_dhyst_timeout_util_4 = 0x0000001A +mc_emem_arb_dhyst_timeout_util_5 = 0x0000001A +mc_emem_arb_dhyst_timeout_util_6 = 0x0000001A +mc_emem_arb_dhyst_timeout_util_7 = 0x0000001A +mc_mll_mpcorer_ptsa_rate = 0x00000115 +mc_ftop_ptsa_rate = 0x00000000 +mc_ptsa_grant_decrement = 0x000017FF +mc_latency_allowance_avpc_0 = 0x004E0004 +mc_latency_allowance_sdmmcaa_0 = 0x004E0005 +mc_latency_allowance_sdmmca_0 = 0x004E0014 +mc_latency_allowance_isp2_0 = 0x0000002C +mc_latency_allowance_isp2_1 = 0x004E004E +mc_latency_allowance_vic_0 = 0x004E0012 +mc_latency_allowance_nvdec_0 = 0x004E0095 +mc_latency_allowance_tsec_0 = 0x004E0041 +mc_latency_allowance_ppcs_1 = 0x004E0080 +mc_latency_allowance_xusb_0 = 0x004E003D +mc_latency_allowance_ppcs_0 = 0x00340049 +mc_latency_allowance_gpu2_0 = 0x004E0010 +mc_latency_allowance_hc_1 = 0x0000004E +mc_latency_allowance_sdmmc_0 = 0x004E0090 +mc_latency_allowance_mpcore_0 = 0x004E0004 +mc_latency_allowance_vi2_0 = 0x0000004E +mc_latency_allowance_hc_0 = 0x0008000E +mc_latency_allowance_gpu_0 = 0x004E0010 +mc_latency_allowance_sdmmcab_0 = 0x004E0005 +mc_latency_allowance_nvenc_0 = 0x004E0018 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2633_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2633_mc.txt new file mode 100644 index 00000000..fb3b042b --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2633_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x68372880 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD8B +MC_SMMU_PTC_FLUSH_0 = 0x784C7621 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000013 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000027 +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001A +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000013 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00140D13 +MC_EMEM_ARB_MISC0_0 = 0x72743C28 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C1D1000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000010E0 +MC_ERR_SEC_ADR_0 = 0x02030000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000005C +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000363 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000D +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x004D0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x004D0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x004D0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x004D0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x004D004D +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x004D0011 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x004D0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x004D0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x004D0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x004D003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x004D000F +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000004D +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x004D0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x004D0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000004D +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000D +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x004D000F +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x004D0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x004D0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2666_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2666_mc.txt new file mode 100644 index 00000000..77f74e4b --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2666_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD5B +MC_SMMU_PTC_FLUSH_0 = 0x77E5A541 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000014 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x800D0080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000A +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RC_0 = 0x00000027 +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001A +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000013 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000004 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00140D13 +MC_EMEM_ARB_MISC0_0 = 0x72743C28 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x00000041 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80030080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000005D +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000363 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000D +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x004C0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x004C0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x004C0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x004C0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x004C004C +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x004C0011 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x004C0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x004C0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x004C0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x004C003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x004C000F +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000004C +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x004C0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x004C0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000004C +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000D +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x004C000F +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x004C0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x004C0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2700_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2700_mc.txt new file mode 100644 index 00000000..d89d3d57 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2700_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FF9DB +MC_SMMU_PTC_FLUSH_0 = 0x0B948741 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000014 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RC_0 = 0x00000028 +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001B +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000014 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00140D14 +MC_EMEM_ARB_MISC0_0 = 0x72753D29 +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C1D1000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80020080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02130810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000005E +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000362 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x004B0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x004B0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x004B0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x004B0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x004B004B +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x004B0011 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x004B0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00990041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x004B0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x004B003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x004B000F +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000004B +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00800090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x004B0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000004B +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000D +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0099001E +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x004B0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x004B0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2733_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2733_mc.txt new file mode 100644 index 00000000..b8b24163 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2733_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCDB +MC_SMMU_PTC_FLUSH_0 = 0x77DEB341 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x08000014 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RC_0 = 0x00000029 +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001B +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000014 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00140E14 +MC_EMEM_ARB_MISC0_0 = 0x72753E2A +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C111000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80040080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000230B0 +MC_ERR_SEC_ADR_0 = 0x0A130810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000005F +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000362 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x004A0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x004A0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x004A0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x004A0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x004A004A +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x004A0011 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x004A0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x004A0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x004A0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x004A003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x004A000F +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000004A +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x004A0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x004A0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000004A +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000D +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x004A000F +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x004A0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x004A0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2766_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2766_mc.txt new file mode 100644 index 00000000..0f2cb621 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2766_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x11210200 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFC5B +MC_SMMU_PTC_FLUSH_0 = 0x77E71141 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000014 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80010080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RC_0 = 0x00000029 +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001C +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000014 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00140E14 +MC_EMEM_ARB_MISC0_0 = 0x72753F2A +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630B0 +MC_ERR_SEC_ADR_0 = 0x0A130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000060 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000362 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000446 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x004A0004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x004A0038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x004A0005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x004A0014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x004A004A +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x004A0011 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x004A0095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x004A0041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x004A0080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x004A003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x004A000F +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x0000004A +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x004A0090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x004A0004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x0000004A +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000D +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x004A000F +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x004A0005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x004A0018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2800_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2800_mc.txt new file mode 100644 index 00000000..0274d5ac --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2800_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCDB +MC_SMMU_PTC_FLUSH_0 = 0x77E18341 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000015 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002A +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001C +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000014 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00140E15 +MC_EMEM_ARB_MISC0_0 = 0x72753F2B +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02112810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000061 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000363 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00490004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00490038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00490005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00490014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00490049 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00490010 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00490095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00490041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00490080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0049003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0049000E +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000049 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00490090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00490004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000049 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000D +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0049000E +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00490005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00490018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2833_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2833_mc.txt new file mode 100644 index 00000000..ba62ac1d --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2833_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCDB +MC_SMMU_PTC_FLUSH_0 = 0x77E5D341 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000015 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002A +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001C +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000015 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00140E15 +MC_EMEM_ARB_MISC0_0 = 0x7276402B +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x800E0080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000010E0 +MC_ERR_SEC_ADR_0 = 0x0A003000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000063 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000363 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00480004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00480038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00480005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00480014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00480048 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00480010 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00480095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00480041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00480080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0048003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0048000E +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000048 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00480090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00480004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000048 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000C +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0048000E +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00480005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00480018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2866_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2866_mc.txt new file mode 100644 index 00000000..65d593b6 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2866_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD0B +MC_SMMU_PTC_FLUSH_0 = 0x77E42421 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x08000015 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000B +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002B +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001D +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000015 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00150E15 +MC_EMEM_ARB_MISC0_0 = 0x7276412C +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000400C1 +MC_ERR_VPR_ADR_0 = 0x0C191020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80040080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x00063070 +MC_ERR_SEC_ADR_0 = 0x02130810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000064 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000363 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00470004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00470038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00470005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00470014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00470047 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00470010 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00470095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00470041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00470080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0047003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0047000E +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000047 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00470090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00470004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000047 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000C +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0047000E +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00470005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00470018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2900_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2900_mc.txt new file mode 100644 index 00000000..875cd83d --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2900_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFD0B +MC_SMMU_PTC_FLUSH_0 = 0x77E8E401 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000015 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000D +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002B +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001D +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000015 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000D +MC_EMEM_ARB_DA_TURNS_0 = 0x06070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00150E15 +MC_EMEM_ARB_MISC0_0 = 0x7276422C +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C1D1020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80030080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x00001060 +MC_ERR_SEC_ADR_0 = 0x02023000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000065 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000363 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00460004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00460038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00460005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00460014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00460046 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00460010 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00460095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00460041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00460080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0046003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0046000E +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000046 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00460090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00460004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000046 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000C +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0046000E +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00460005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00460018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2933_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2933_mc.txt new file mode 100644 index 00000000..b586e700 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2933_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFBDB +MC_SMMU_PTC_FLUSH_0 = 0x31050F41 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000016 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80010080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000D +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002C +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001D +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000015 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000E +MC_EMEM_ARB_DA_TURNS_0 = 0x07070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00150E16 +MC_EMEM_ARB_MISC0_0 = 0x7276422D +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C1D1000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x42130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000066 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000363 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00450004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00450038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00450005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00450014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00450045 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00450010 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00990095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00450041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00450080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0045003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0045000E +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000045 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00450090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00450004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000045 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000C +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0045000E +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00450005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00450018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2966_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2966_mc.txt new file mode 100644 index 00000000..25661781 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/2966_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFC9B +MC_SMMU_PTC_FLUSH_0 = 0x77EA0261 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000016 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000D +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002C +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001E +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000016 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000E +MC_EMEM_ARB_DA_TURNS_0 = 0x07070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00150F16 +MC_EMEM_ARB_MISC0_0 = 0x7257432D +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C1D1000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000230F0 +MC_ERR_SEC_ADR_0 = 0x02130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000067 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000362 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000B +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00450004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00450038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00450005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00450014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00450045 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x00450010 +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00450095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00450041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00450080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0045003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0045000E +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000045 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00450090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00450004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000045 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000C +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0045000E +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00450005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00450018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/3000_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/3000_mc.txt new file mode 100644 index 00000000..a24d0c50 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/3000_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x19211200 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFE4B +MC_SMMU_PTC_FLUSH_0 = 0x7A43E911 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x08000016 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80010080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000D +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002C +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001E +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000016 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000E +MC_EMEM_ARB_DA_TURNS_0 = 0x07070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00150F16 +MC_EMEM_ARB_MISC0_0 = 0x7277442D +C_EMEM_ARB_MISC1_0 = 0x70000F0F +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000400C0 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02910810 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x00000068 +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000362 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000B +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00440004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00440038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00440005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00440014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00440044 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x0044000F +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00440095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00440041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00440080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0044003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0044000D +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000044 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00440090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00440004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000044 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000C +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0044000D +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00440005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00440018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/3033_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/3033_mc.txt new file mode 100644 index 00000000..63a530c1 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/3033_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFC8B +MC_SMMU_PTC_FLUSH_0 = 0x77D7A221 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x0C000016 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000D +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002D +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001E +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000016 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000003 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000E +MC_EMEM_ARB_DA_TURNS_0 = 0x07070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00150F16 +MC_EMEM_ARB_MISC0_0 = 0x7277452E +C_EMEM_ARB_MISC1_0 = 0x70000F0E +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C1 +MC_ERR_VPR_ADR_0 = 0x0C191000 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000010E0 +MC_ERR_SEC_ADR_0 = 0x02003000 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000006A +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000362 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000B +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00430004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00430038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00430005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00430014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00430043 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x0043000F +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00430095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00430041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00430080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0043003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0043000D +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000043 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00430090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00430004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000043 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000C +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0043000D +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00430005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00430018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/3066_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/3066_mc.txt new file mode 100644 index 00000000..e16dac72 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/3066_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCEB +MC_SMMU_PTC_FLUSH_0 = 0x77E1F3B1 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x00000017 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80000080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000D +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002D +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001E +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000016 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000003 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x0000000D +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000E +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000E +MC_EMEM_ARB_DA_TURNS_0 = 0x07070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00160F16 +MC_EMEM_ARB_MISC0_0 = 0x7277452E +C_EMEM_ARB_MISC1_0 = 0x70000F0E +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C1D1020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80010080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x000630F0 +MC_ERR_SEC_ADR_0 = 0x02130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000006B +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000362 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000B +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00420004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00420038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00420005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00420014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00420042 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x0042000F +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00420095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00420041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00420080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0042003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0042000D +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000042 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00420090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00420004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000042 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000C +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0042000D +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00420005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00420018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/3100_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/3100_mc.txt new file mode 100644 index 00000000..dbbb4b23 --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/3100_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x7FFFFFE0 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFB5B +MC_SMMU_PTC_FLUSH_0 = 0x7A3C0D41 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x04000017 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80020080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000C +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000D +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002D +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001E +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000017 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000F +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000E +MC_EMEM_ARB_DA_TURNS_0 = 0x07070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00160F16 +MC_EMEM_ARB_MISC0_0 = 0x7258462E +C_EMEM_ARB_MISC1_0 = 0x70000F0E +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x000000C0 +MC_ERR_VPR_ADR_0 = 0x0C1D1020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x00063070 +MC_ERR_SEC_ADR_0 = 0x02130100 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000006C +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000362 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000B +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x00000C63 +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00420038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00800005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00800014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00800080 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x0080001D +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00420095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00800041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00420080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0080003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0042000D +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000042 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00420090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00420004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000042 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000B +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0042000D +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00420005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00420018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/3133_mc.txt b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/3133_mc.txt new file mode 100644 index 00000000..e7176b3f --- /dev/null +++ b/Source/TimingTool/timings/K4U6E3S4AA-MGCL/2133/mc/3133_mc.txt @@ -0,0 +1,288 @@ +Dumping MC registers from BASE=0x70019000 +----------------------------------- +MC_ERR_ADR_0 = 0x01011200 +MC_SMMU_CONFIG_0 = 0xFFFFFFFF +MC_SMMU_TLB_CONFIG_0 = 0x30000030 +MC_SMMU_PTC_CONFIG_0 = 0x2800003F +MC_SMMU_PTB_ASID_0 = 0x0000000C +MC_SMMU_PTB_DATA_0 = 0xE00FF80C +MC_SMMU_TLB_FLUSH_0 = 0x000FFCCB +MC_SMMU_PTC_FLUSH_0 = 0x77DD8331 +MC_EMEM_CFG_0 = 0x00001000 +MC_EMEM_ROW_WIDTH = 0x00000000 +MC_EMEM_ADR_CFG_DEV0_0 = 0x00080302 +MC_EMEM_ADR_CFG_DEV1_0 = 0x00080302 +MC_EMEM_ADR_CFG_CHANNEL_MASK_0 = 0xFFFF2400 +MC_EMEM_ADR_CFG_BANK_MASK_0_0 = 0x6E574400 +MC_EMEM_ADR_CFG_BANK_MASK_1_0 = 0x39722800 +MC_EMEM_ADR_CFG_BANK_MASK_2_0 = 0x4B9C1000 +MC_SECURITY_CFG0_0 = 0xFFFFFFFF +MC_SECURITY_CFG1_0 = 0xFFFFFFFF +MC_EMEM_ARB_CFG_0 = 0x08000017 +MC_EMEM_ARB_OUTSTANDING_REQ_0 = 0x80010080 +MC_EMEM_ARB_TIMING_RCD_0 = 0x0000000D +MC_EMEM_ARB_TIMING_RP_0 = 0x0000000E +MC_EMEM_ARB_TIMING_RC_0 = 0x0000002D +MC_EMEM_ARB_TIMING_RAS_0 = 0x0000001E +MC_EMEM_ARB_TIMING_FAW_0 = 0x00000017 +MC_EMEM_ARB_TIMING_RRD_0 = 0x00000005 +MC_EMEM_ARB_TIMING_RAP2PRE_0 = 0x00000004 +MC_EMEM_ARB_TIMING_WAP2PRE_0 = 0x00000011 +MC_EMEM_ARB_TIMING_R2R_0 = 0x00000001 +MC_EMEM_ARB_TIMING_W2W_0 = 0x00000001 +MC_EMEM_ARB_TIMING_R2W_0 = 0x0000000F +MC_EMEM_ARB_TIMING_W2R_0 = 0x0000000E +MC_EMEM_ARB_DA_TURNS_0 = 0x07070000 +MC_EMEM_ARB_DA_COVERS_0 = 0x00160F16 +MC_EMEM_ARB_MISC0_0 = 0x7258472E +C_EMEM_ARB_MISC1_0 = 0x70000F0E +MC_EMEM_ARB_MISC2_0 = 0x00000000 +MC_EMEM_ARB_RING1_THROTTLE_0 = 0x001F0000 +MC_EMEM_ARB_RING3_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_OVERRIDE_0 = 0x10000000 +MC_EMEM_ARB_RSV_0 = 0xFF00FF00 +MC_CLKEN_OVERRIDE_0 = 0x00008000 +MC_TIMING_CONTROL_0 = 0x00000001 +MC_STAT_CONTROL_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_0 = 0x000E0900 +MC_CLIENT_HOTRESET_STATUS_0 = 0x002E8900 +MC_EMEM_ARB_ISOCHRONOUS_0_0 = 0x0023007E +MC_EMEM_ARB_ISOCHRONOUS_1_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_2_0 = 0x04000000 +MC_EMEM_ARB_ISOCHRONOUS_3_0 = 0x00080000 +MC_EMEM_ARB_HYSTERESIS_0_0 = 0x0003007E +MC_EMEM_ARB_HYSTERESIS_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_2_0 = 0x04000000 +MC_EMEM_ARB_HYSTERESIS_3_0 = 0x00080000 +MC_SMMU_AFI_ASID_0 = 0x8000000B +MC_SMMU_AVPC_ASID_0 = 0x80000002 +MC_SMMU_DC_ASID_0 = 0x80000005 +MC_SMMU_DCB_ASID_0 = 0x80000006 +MC_SMMU_HC_ASID_0 = 0x80000000 +MC_SMMU_HDA_ASID_0 = 0x00000000 +MC_SMMU_ISP2_ASID_0 = 0x00000000 +MC_SMMU_NVENC_ASID_0 = 0x80000000 +MC_SMMU_NV_ASID_0 = 0x00000000 +MC_SMMU_NV2_ASID_0 = 0x00000000 +MC_SMMU_PPCS_ASID_0 = 0x80000003 +MC_SMMU_SATA_ASID_0 = 0x00000000 +MC_SMMU_VI_ASID_0 = 0x00000000 +MC_SMMU_VIC_ASID_0 = 0x80000000 +MC_SMMU_XUSB_HOST_ASID_0 = 0x80000000 +MC_SMMU_XUSB_DEV_ASID_0 = 0x80000000 +MC_SMMU_TSEC_ASID_0 = 0x80000000 +MC_SMMU_PPCS1_ASID_0 = 0x80000003 +MC_VIDEO_PROTECT_VPR_OVERRIDE_0 = 0xE4FACB43 +MC_VIDEO_PROTECT_VPR_OVERRIDE1_0 = 0x0600FED3 +MC_SMMU_TLB_SET_SELECTION_MASK_0_0 = 0x00008000 +MC_DISPLAY_SNAP_RING_0 = 0x00000000 +MC_ERR_VPR_STATUS_0 = 0x00000040 +MC_ERR_VPR_ADR_0 = 0x0C1D1020 +MC_IRAM_REG_CTRL_0 = 0x00000001 +MC_EMEM_CFG_ACCESS_CTRL_0 = 0x00000001 +MC_TZ_SECURITY_CTRL_0 = 0x00000000 +MC_EMEM_ARB_OUTSTANDING_REQ_RING3_0 = 0x80000080 +MC_SEC_CARVEOUT_BOM_0 = 0xFFF00000 +MC_SEC_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_SEC_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_ERR_SEC_STATUS_0 = 0x00063070 +MC_ERR_SEC_ADR_0 = 0x02130800 +MC_PC_IDLE_CLOCK_GATE_CONFIG_0 = 0x0000001F +MC_STUTTER_CONTROL_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_0 = 0x00000000 +MC_EMEM_ARB_RING0_THROTTLE_MASK_0 = 0x80008041 +MC_EMEM_ARB_TIMING_RFCPB_0 = 0x0000006D +MC_EMEM_ARB_TIMING_CCDMW_0 = 0x00000008 +MC_EMEM_ARB_REFPB_HP_CTRL_0 = 0x000A1020 +MC_EMEM_ARB_REFPB_BANK_CTRL_0 = 0x80001028 +MC_EMEM_ARB_OVERRIDE_1_0 = 0x00000000 +MC_CLIENT_HOTRESET_CTRL_1_0 = 0x00000122 +MC_CLIENT_HOTRESET_STATUS_1_0 = 0x00000122 +MC_VIDEO_PROTECT_GPU_OVERRIDE_0_0 = 0x2A800000 +MC_VIDEO_PROTECT_GPU_OVERRIDE_1_0 = 0x00000002 +MC_MTS_CARVEOUT_BOM_0 = 0xFFF00000 +MC_MTS_CARVEOUT_SIZE_MB_0 = 0x00000000 +MC_MTS_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_MTS_CARVEOUT_REG_CTRL_0 = 0x00000000 +MC_SMMU_PTC_FLUSH_1_0 = 0x00000001 +MC_SECURITY_CFG3_0 = 0xFFFFFFFF +MC_EMEM_BANK_SWIZZLE_CFG0_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG1_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG2_0 = 0x00000000 +MC_EMEM_BANK_SWIZZLE_CFG3_0 = 0x00000000 +MC_SEC_CARVEOUT_ADR_HI_0 = 0x00000000 +MC_SMMU_DC1_ASID_0 = 0x80000005 +MC_SMMU_SDMMC1A_ASID_0 = 0x8000000C +MC_SMMU_SDMMC2A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC3A_ASID_0 = 0x00000000 +MC_SMMU_SDMMC4A_ASID_0 = 0x00000000 +MC_SMMU_ISP2B_ASID_0 = 0x80000003 +MC_SMMU_GPU_ASID_0 = 0x00000000 +MC_SMMU_GPUB_ASID_0 = 0x8A090807 +MC_SMMU_PPCS2_ASID_0 = 0x80000003 +MC_SMMU_NVDEC_ASID_0 = 0x80000000 +MC_SMMU_APE_ASID_0 = 0x80000004 +MC_SMMU_SE_ASID_0 = 0x80000003 +MC_SMMU_NVJPG_ASID_0 = 0x80000000 +MC_SMMU_HC1_ASID_0 = 0x00000000 +MC_SMMU_SE1_ASID_0 = 0x80000003 +MC_SMMU_AXIAP_ASID_0 = 0x00000000 +MC_SMMU_ETR_ASID_0 = 0x00000000 +MC_SMMU_TSECB_ASID_0 = 0x80000000 +MC_SMMU_TSEC1_ASID_0 = 0x00000000 +MC_SMMU_TSECB1_ASID_0 = 0x00000000 +MC_SMMU_NVDEC1_ASID_0 = 0x00000000 +MC_EMEM_ARB_NISO_THROTTLE_MASK_1_0 = 0x00000000 +MC_EMEM_ARB_HYSTERESIS_4_0 = 0x00000000 +MC_EMEM_ARB_ISOCHRONOUS_4_0 = 0x00000000 +MC_EMEM_ARB_DHYSTERESIS_0_0 = 0x10000000 +MC_EMEM_ARB_DHYSTERESIS_1_0 = 0x00000800 +MC_EMEM_ARB_DHYSTERESIS_2_0 = 0x030340D0 +MC_EMEM_ARB_DHYSTERESIS_3_0 = 0xC3043000 +MC_EMEM_ARB_DHYSTERESIS_4_0 = 0x00000300 +MC_EMEM_ARB_DHYST_CTRL_0 = 0x00000002 +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6_0 = 0x0000001A +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7_0 = 0x0000001A +MC_DA_CONFIG0_0 = 0x00000001 +MC_AHB_PTSA_MIN_0 = 0x0000003E +MC_AUD_PTSA_MIN_0 = 0x0000003B +MC_MLL_MPCORER_PTSA_RATE_0 = 0x00000115 +MC_RING2_PTSA_RATE_0 = 0x0000000C +MC_USBD_PTSA_RATE_0 = 0x00000000 +MC_USBX_PTSA_MIN_0 = 0x0000003E +MC_USBD_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MAX_0 = 0x00000000 +MC_JPG_PTSA_RATE_0 = 0x00000000 +MC_DIS_PTSA_MIN_0 = 0x0000003B +MC_AVP_PTSA_MAX_0 = 0x00000000 +MC_AVP_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MIN_0 = 0x0000003B +MC_DIS_PTSA_MAX_0 = 0x0000001F +MC_SD_PTSA_MAX_0 = 0x00000000 +MC_MSE_PTSA_RATE_0 = 0x00000000 +MC_VICPC_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_MAX_0 = 0x00000000 +MC_ISP_PTSA_RATE_0 = 0x00000000 +MC_A9AVPPC_PTSA_MIN_0 = 0x0000003B +MC_RING2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_RATE_0 = 0x00000000 +MC_HOST_PTSA_MIN_0 = 0x0000003E +MC_MLL_MPCORER_PTSA_MAX_0 = 0x00000004 +MC_SD_PTSA_MIN_0 = 0x0000003E +MC_RING1_PTSA_RATE_0 = 0x00000362 +MC_JPG_PTSA_MIN_0 = 0x0000003E +MC_HDAPC_PTSA_MIN_0 = 0x0000003E +MC_AVP_PTSA_MIN_0 = 0x0000003E +MC_JPG_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MAX_0 = 0x0000001F +MC_DFD_PTSA_MAX_0 = 0x0000003F +MC_VICPC_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_MAX_0 = 0x00000000 +MC_VICPC_PTSA_MAX_0 = 0x00000000 +MC_SDM_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_RATE_0 = 0x00000000 +MC_PCX_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_MIN_0 = 0x0000003E +MC_GK2_PTSA_MIN_0 = 0x0000003E +MC_PCX_PTSA_RATE_0 = 0x00000000 +MC_RING1_PTSA_MAX_0 = 0x0000001F +MC_HDAPC_PTSA_RATE_0 = 0x00000000 +MC_MLL_MPCORER_PTSA_MIN_0 = 0x0000003C +MC_GK2_PTSA_MAX_0 = 0x00000000 +MC_AUD_PTSA_MAX_0 = 0x0000001F +MC_GK2_PTSA_RATE_0 = 0x00000000 +MC_ISP_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_RATE_0 = 0x00000447 +MC_VE2_PTSA_MAX_0 = 0x00000000 +MC_DFD_PTSA_MIN_0 = 0x0000003F +MC_FTOP_PTSA_RATE_0 = 0x0000001F +MC_A9AVPPC_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_MIN_0 = 0x0000003E +MC_USBX_PTSA_MAX_0 = 0x00000000 +MC_DIS_PTSA_RATE_0 = 0x0000000B +MC_USBD_PTSA_MAX_0 = 0x00000000 +MC_A9AVPPC_PTSA_MAX_0 = 0x00000010 +MC_USBX_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MAX_0 = 0x00000000 +MC_HDAPC_PTSA_MAX_0 = 0x00000000 +MC_SD_PTSA_RATE_0 = 0x00000000 +MC_DFD_PTSA_RATE_0 = 0x00000000 +MC_FTOP_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_RATE_0 = 0x00000000 +MC_SMMU_SMMU_PTSA_MAX_0 = 0x00000001 +MC_RING2_PTSA_MIN_0 = 0x0000003E +MC_SDM_PTSA_MIN_0 = 0x0000003E +MC_APB_PTSA_RATE_0 = 0x00000000 +MC_MSE_PTSA_MIN_0 = 0x0000003E +MC_HOST_PTSA_RATE_0 = 0x00000000 +MC_VE_PTSA_RATE_0 = 0x00000000 +MC_AHB_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MIN_0 = 0x0000003E +MC_SMMU_SMMU_PTSA_MIN_0 = 0x00000001 +MC_ISP_PTSA_MIN_0 = 0x0000003B +MC_HOST_PTSA_MAX_0 = 0x00000000 +MC_SAX_PTSA_MAX_0 = 0x00000000 +MC_VE_PTSA_MIN_0 = 0x0000003B +MC_GK_PTSA_MIN_0 = 0x0000003E +MC_MSE_PTSA_MAX_0 = 0x00000000 +MC_DISB_PTSA_MAX_0 = 0x0000001F +MC_DISB_PTSA_MIN_0 = 0x0000003B +MC_SMMU_SMMU_PTSA_RATE_0 = 0x00000000 +MC_VE2_PTSA_RATE_0 = 0x00000000 +MC_GK_PTSA_RATE_0 = 0x00000000 +MC_PTSA_GRANT_DECREMENT_0 = 0x000017FF +MC_LATENCY_ALLOWANCE_AVPC_0_0 = 0x00410004 +MC_LATENCY_ALLOWANCE_AXIAP_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_XUSB_1_0 = 0x00410038 +MC_LATENCY_ALLOWANCE_ISP2B_0_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMCAA_0_0 = 0x00410005 +MC_LATENCY_ALLOWANCE_SDMMCA_0_0 = 0x00410014 +MC_LATENCY_ALLOWANCE_ISP2_0_0 = 0x0000002C +MC_LATENCY_ALLOWANCE_SE_0_0 = 0x0080002E +MC_LATENCY_ALLOWANCE_ISP2_1_0 = 0x00410041 +MC_LATENCY_ALLOWANCE_DC_0_0 = 0x001E00FF +MC_LATENCY_ALLOWANCE_VIC_0_0 = 0x0041000F +MC_LATENCY_ALLOWANCE_DCB_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_NVDEC_0_0 = 0x00410095 +MC_LATENCY_ALLOWANCE_DCB_2_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_TSEC_0_0 = 0x00410041 +MC_LATENCY_ALLOWANCE_DC_2_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0AB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_PPCS_1_0 = 0x00410080 +MC_LATENCY_ALLOWANCE_XUSB_0_0 = 0x0041003D +MC_LATENCY_ALLOWANCE_PPCS_0_0 = 0x00340049 +MC_LATENCY_ALLOWANCE_TSECB_0_0 = 0x00FF009D +MC_LATENCY_ALLOWANCE_AFI_0_0 = 0x00FF0073 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0B_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_DC_1_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_APE_0_0 = 0x008000FF +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0C_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_A9AVP_0_0 = 0x00800004 +MC_LATENCY_ALLOWANCE_GPU2_0_0 = 0x0041000D +MC_LATENCY_ALLOWANCE_DCB_0_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_HC_1_0 = 0x00000041 +MC_LATENCY_ALLOWANCE_SDMMC_0_0 = 0x00410090 +MC_LATENCY_ALLOWANCE_NVJPG_0_0 = 0x00800023 +MC_LATENCY_ALLOWANCE_PTC_0_0 = 0x00000000 +MC_LATENCY_ALLOWANCE_ETR_0_0 = 0x008000FF +MC_LATENCY_ALLOWANCE_MPCORE_0_0 = 0x00410004 +MC_LATENCY_ALLOWANCE_VI2_0_0 = 0x00000041 +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0BB_0 = 0x001E001E +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0CB_0 = 0x001E001E +MC_LATENCY_ALLOWANCE_SATA_0_0 = 0x00FF00CB +MC_SCALED_LATENCY_ALLOWANCE_DISPLAY0A_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_HC_0_0 = 0x0008000B +MC_LATENCY_ALLOWANCE_DC_3_0 = 0x0000001E +MC_LATENCY_ALLOWANCE_GPU_0_0 = 0x0041000D +MC_LATENCY_ALLOWANCE_SDMMCAB_0_0 = 0x00410005 +MC_LATENCY_ALLOWANCE_ISP2B_1_0 = 0x00FF00FF +MC_LATENCY_ALLOWANCE_NVENC_0_0 = 0x00410018 +MC_LATENCY_ALLOWANCE_HDA_0_0 = 0x00FF0024 diff --git a/Source/ams_patch.bat b/Source/ams_patch.bat new file mode 100644 index 00000000..02428619 --- /dev/null +++ b/Source/ams_patch.bat @@ -0,0 +1,10 @@ +@echo off +set ROOT=Atmosphere-MTC-Unlock +set PATCHES=Atmosphere-Patches +copy "%PATCHES%\secmon_memory_layout.hpp" "%ROOT%\libraries\libexosphere/include/exosphere/secmon/" /Y +copy "%PATCHES%\secmon_emc_access_table_data.inc" "%ROOT%\exosphere/program/source/smc/" /Y +copy "%PATCHES%\secmon_define_emc_access_table.inc" "%ROOT%\exosphere/program/source/smc/" /Y +copy "%PATCHES%\secmon_smc_register_access.cpp" "%ROOT%\exosphere/program/source/smc/" /Y + +echo Patched! +pause diff --git a/Source/sys-clk/build.sh b/Source/sys-clk/build.sh index c6978c5c..9b4a2df5 100644 --- a/Source/sys-clk/build.sh +++ b/Source/sys-clk/build.sh @@ -20,7 +20,7 @@ make -j$CORES popd > /dev/null mkdir -p "$DIST_DIR/atmosphere/contents/$TITLE_ID/flags" -cp -vf "$ROOT_DIR/sysmodule/out/sys-clk.nsp" "$DIST_DIR/atmosphere/contents/$TITLE_ID/exefs.nsp" +cp -vf "$ROOT_DIR/sysmodule/out/horizon-oc.nsp" "$DIST_DIR/atmosphere/contents/$TITLE_ID/exefs.nsp" >"$DIST_DIR/atmosphere/contents/$TITLE_ID/flags/boot2.flag" cp -vf "$ROOT_DIR/sysmodule/toolbox.json" "$DIST_DIR/atmosphere/contents/$TITLE_ID/toolbox.json" echo "*** manager ***" @@ -29,7 +29,7 @@ make -j$CORES popd > /dev/null mkdir -p "$DIST_DIR/switch" -cp -vf "$ROOT_DIR/manager/sys-clk-manager.nro" "$DIST_DIR/switch/sys-clk-manager.nro" +cp -vf "$ROOT_DIR/manager/horizon-oc-manager.nro" "$DIST_DIR/switch/horizon-oc-manager.nro" echo "*** overlay ***" pushd "$ROOT_DIR/overlay" @@ -37,9 +37,9 @@ make -j$CORES popd > /dev/null mkdir -p "$DIST_DIR/switch/.overlays" -cp -vf "$ROOT_DIR/overlay/out/sys-clk-overlay.ovl" "$DIST_DIR/switch/.overlays/sys-clk-overlay.ovl" +cp -vf "$ROOT_DIR/overlay/out/horizon-oc-overlay.ovl" "$DIST_DIR/switch/.overlays/horizon-oc-overlay.ovl" echo "*** assets ***" -mkdir -p "$DIST_DIR/config/sys-clk" -cp -vf "$ROOT_DIR/config.ini.template" "$DIST_DIR/config/sys-clk/config.ini.template" +mkdir -p "$DIST_DIR/config/horizon-oc" +cp -vf "$ROOT_DIR/config.ini.template" "$DIST_DIR/config/horizon-oc/config.ini.template" cp -vf "$ROOT_DIR/../../README.md" "$DIST_DIR/README.md" diff --git a/Source/sys-clk/common/include/sysclk.h b/Source/sys-clk/common/include/sysclk.h index e9befcaf..6ba0c4a8 100644 --- a/Source/sys-clk/common/include/sysclk.h +++ b/Source/sys-clk/common/include/sysclk.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,13 +24,23 @@ * -------------------------------------------------------------------------- */ -#pragma once +#pragma once +#include #ifdef __cplusplus #include "cpp_util.hpp" extern "C" { #endif +typedef std::uint32_t Result; +typedef std::uint32_t u32; +typedef std::int32_t s32; +typedef std::uint64_t u64; +typedef std::int64_t s64; +typedef std::uint8_t u8; +typedef std::int16_t s16; +typedef std::uint16_t u16; + #include "sysclk/ipc.h" #include "sysclk/board.h" #include "sysclk/clock_manager.h" diff --git a/Source/sys-clk/common/include/sysclk/apm.h b/Source/sys-clk/common/include/sysclk/apm.h index c2106517..e6442896 100644 --- a/Source/sys-clk/common/include/sysclk/apm.h +++ b/Source/sys-clk/common/include/sysclk/apm.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include "board.h" diff --git a/Source/sys-clk/common/include/sysclk/board.h b/Source/sys-clk/common/include/sysclk/board.h index 43849629..9fa6c625 100644 --- a/Source/sys-clk/common/include/sysclk/board.h +++ b/Source/sys-clk/common/include/sysclk/board.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include @@ -18,6 +35,7 @@ typedef enum { SysClkSocType_Erista = 0, SysClkSocType_Mariko, + SysClkSocType_MarikoLite, SysClkSocType_EnumMax } SysClkSocType; @@ -36,7 +54,7 @@ typedef enum SysClkModule_CPU = 0, SysClkModule_GPU, SysClkModule_MEM, - SysClkModule_EnumMax + SysClkModule_EnumMax, } SysClkModule; typedef enum @@ -56,10 +74,11 @@ typedef enum typedef enum { - SysClkRamLoad_All = 0, - SysClkRamLoad_Cpu, - SysClkRamLoad_EnumMax -} SysClkRamLoad; + SysClkPartLoad_EMC = 0, + SysClkPartLoad_EMCCpu, + HocClkPartLoad_GPU, + SysClkPartLoad_EnumMax +} SysClkPartLoad; typedef enum { diff --git a/Source/sys-clk/common/include/sysclk/client/ipc.h b/Source/sys-clk/common/include/sysclk/client/ipc.h index c903807f..bca22fee 100644 --- a/Source/sys-clk/common/include/sysclk/client/ipc.h +++ b/Source/sys-clk/common/include/sysclk/client/ipc.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include "types.h" @@ -32,6 +49,7 @@ Result sysclkIpcGetConfigValues(SysClkConfigValueList* out_configValues); Result sysclkIpcSetConfigValues(SysClkConfigValueList* configValues); Result sysclkIpcGetFreqList(SysClkModule module, u32* list, u32 maxCount, u32* outCount); Result sysclkIpcSetReverseNXRTMode(ReverseNXMode mode); +Result hocClkIpcUpdateEmcRegs(); static inline Result sysclkIpcRemoveOverride(SysClkModule module) { diff --git a/Source/sys-clk/common/include/sysclk/client/types.h b/Source/sys-clk/common/include/sysclk/client/types.h index 2e67315a..b2aec78d 100644 --- a/Source/sys-clk/common/include/sysclk/client/types.h +++ b/Source/sys-clk/common/include/sysclk/client/types.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #ifdef __SWITCH__ diff --git a/Source/sys-clk/common/include/sysclk/clock_manager.h b/Source/sys-clk/common/include/sysclk/clock_manager.h index 74f329bd..72bd830a 100644 --- a/Source/sys-clk/common/include/sysclk/clock_manager.h +++ b/Source/sys-clk/common/include/sysclk/clock_manager.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include @@ -23,16 +40,16 @@ typedef struct uint32_t overrideFreqs[SysClkModule_EnumMax]; uint32_t temps[SysClkThermalSensor_EnumMax]; int32_t power[SysClkPowerSensor_EnumMax]; - uint32_t ramLoad[SysClkRamLoad_EnumMax]; - uint32_t perfConfId; + uint32_t partLoad[SysClkPartLoad_EnumMax]; +// uint32_t perfConfId; } SysClkContext; typedef struct { union { - uint32_t mhz[SysClkProfile_EnumMax * SysClkModule_EnumMax]; - uint32_t mhzMap[SysClkProfile_EnumMax][SysClkModule_EnumMax]; + uint32_t mhz[(uint32_t)SysClkProfile_EnumMax * (uint32_t)SysClkModule_EnumMax]; + uint32_t mhzMap[(uint32_t)SysClkProfile_EnumMax][(uint32_t)SysClkModule_EnumMax]; }; } SysClkTitleProfileList; -#define SYSCLK_FREQ_LIST_MAX 32 +#define SYSCLK_FREQ_LIST_MAX 32 \ No newline at end of file diff --git a/Source/sys-clk/common/include/sysclk/config.h b/Source/sys-clk/common/include/sysclk/config.h index 0753bccb..7060502a 100644 --- a/Source/sys-clk/common/include/sysclk/config.h +++ b/Source/sys-clk/common/include/sysclk/config.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include @@ -19,11 +36,36 @@ typedef enum { SysClkConfigValue_FreqLogIntervalMs, SysClkConfigValue_PowerLogIntervalMs, SysClkConfigValue_CsvWriteIntervalMs, + HocClkConfigValue_UncappedClocks, HocClkConfigValue_OverwriteBoostMode, - HocClkConfigValue_SyncReverseNXMode, - HocClkConfigValue_DockedGovernor, + + HocClkConfigValue_EristaMaxCpuClock, + HocClkConfigValue_EristaMaxGpuClock, + HocClkConfigValue_EristaMaxMemClock, + HocClkConfigValue_MarikoMaxCpuClock, + HocClkConfigValue_MarikoMaxGpuClock, + HocClkConfigValue_MarikoMaxMemClock, + + HocClkConfigValue_MarikoCpuBoostClock, + HocClkConfigValue_EristaCpuBoostClock, + + HocClkConfigValue_ThermalThrottle, + HocClkConfigValue_ThermalThrottleThreshold, + HocClkConfigValue_HandheldGovernor, + HocClkConfigValue_DockedGovernor, + + HocClkConfigValue_HandheldTDP, + HocClkConfigValue_HandheldTDPLimit, + HocClkConfigValue_LiteTDPLimit, + + HocClkConfigValue_EnforceBoardLimit, + + HocClkConfigValue_EMCDVFS, + HocClkConfigValue_EMCVdd2VoltageUV, + HocClkConfigValue_EMCVdd2VoltageUVStockErista, + HocClkConfigValue_EMCVdd2VoltageUVStockMariko, SysClkConfigValue_EnumMax, } SysClkConfigValue; @@ -49,14 +91,59 @@ static inline const char* sysclkFormatConfigValue(SysClkConfigValue val, bool pr return pretty ? "Uncapped Clocks" : "uncapped_clocks"; case HocClkConfigValue_OverwriteBoostMode: return pretty ? "Overwrite Boost Mode" : "ow_boost"; - case HocClkConfigValue_SyncReverseNXMode: - return pretty ? "ReverseNX Sync" : "rnx_sync"; + + case HocClkConfigValue_EristaMaxCpuClock: + return pretty ? "Max CPU Clock" : "cpu_max_e"; + case HocClkConfigValue_EristaMaxGpuClock: + return pretty ? "Max GPU Clock" : "gpu_max_e"; + case HocClkConfigValue_EristaMaxMemClock: + return pretty ? "Max MEM Clock" : "mem_max_e"; + + case HocClkConfigValue_MarikoMaxCpuClock: + return pretty ? "Max CPU Clock" : "cpu_max_m"; + case HocClkConfigValue_MarikoMaxGpuClock: + return pretty ? "Max GPU Clock" : "gpu_max_m"; + case HocClkConfigValue_MarikoMaxMemClock: + return pretty ? "Max MEM Clock" : "mem_max_m"; + + case HocClkConfigValue_MarikoCpuBoostClock: + return pretty ? "CPU Boost Clock" : "cpu_boost_m"; + + case HocClkConfigValue_EristaCpuBoostClock: + return pretty ? "CPU Boost Clock" : "cpu_boost_e"; + + case HocClkConfigValue_ThermalThrottle: + return pretty ? "Thermal Throttle" : "thermal_throttle"; + + case HocClkConfigValue_ThermalThrottleThreshold: + return pretty ? "Thermal Throttle Threshold" : "thermal_throttle_threshold"; + case HocClkConfigValue_DockedGovernor: - return pretty ? "Docked Governor" : "governor_d"; + return pretty ? "Docked Governor" : "governor_docked"; case HocClkConfigValue_HandheldGovernor: - return pretty ? "Handheld Governor" : "governor_hh"; + return pretty ? "Handheld Governor" : "governor_handheld"; + + case HocClkConfigValue_HandheldTDP: + return pretty ? "Handheld TDP" : "handheld_tdp"; + + case HocClkConfigValue_HandheldTDPLimit: + return pretty ? "TDP Limit" : "tdp_limit"; + + case HocClkConfigValue_LiteTDPLimit: + return pretty ? "Lite TDP Limit" : "tdp_limit_l"; + + case HocClkConfigValue_EnforceBoardLimit: + return pretty ? "Enforce Board Limit" : "enforce_board_limit"; + case HocClkConfigValue_EMCDVFS: + return pretty ? "EMC DVFS" : "emc_dvfs"; + case HocClkConfigValue_EMCVdd2VoltageUV: + return pretty ? "Overclocked EMC Vdd2 Voltage" : "emc_vdd2_voltage_uv"; + case HocClkConfigValue_EMCVdd2VoltageUVStockErista: + return pretty ? "Stock EMC Vdd2 Voltage" : "emc_vdd2_voltage_uv_s_e"; + case HocClkConfigValue_EMCVdd2VoltageUVStockMariko: + return pretty ? "Stock EMC Vdd2 Voltage" : "emc_vdd2_voltage_uv_s_m"; default: - return NULL; + return pretty ? "Null" : "null"; } } @@ -72,8 +159,42 @@ static inline uint64_t sysclkDefaultConfigValue(SysClkConfigValue val) case SysClkConfigValue_CsvWriteIntervalMs: case HocClkConfigValue_UncappedClocks: case HocClkConfigValue_OverwriteBoostMode: - case HocClkConfigValue_SyncReverseNXMode: return 0ULL; + case HocClkConfigValue_EristaMaxCpuClock: + case HocClkConfigValue_EristaCpuBoostClock: + return 1785ULL; + case HocClkConfigValue_EristaMaxGpuClock: + return 921ULL; + case HocClkConfigValue_EristaMaxMemClock: + return 1600ULL; + + case HocClkConfigValue_MarikoMaxCpuClock: + case HocClkConfigValue_MarikoCpuBoostClock: + return 1963ULL; + case HocClkConfigValue_MarikoMaxGpuClock: + return 1152ULL; + case HocClkConfigValue_MarikoMaxMemClock: + return 1862ULL; + + case HocClkConfigValue_ThermalThrottle: + case HocClkConfigValue_DockedGovernor: + case HocClkConfigValue_HandheldGovernor: + case HocClkConfigValue_HandheldTDP: + case HocClkConfigValue_EnforceBoardLimit: + case HocClkConfigValue_EMCDVFS: + return 1ULL; + case HocClkConfigValue_ThermalThrottleThreshold: + return 70ULL; + case HocClkConfigValue_HandheldTDPLimit: + return 8600ULL; + case HocClkConfigValue_LiteTDPLimit: + return 6400ULL; + case HocClkConfigValue_EMCVdd2VoltageUV: + return 1175000ULL; + case HocClkConfigValue_EMCVdd2VoltageUVStockErista: + return 1125000ULL; + case HocClkConfigValue_EMCVdd2VoltageUVStockMariko: + return 1100000ULL; default: return 0ULL; } @@ -83,16 +204,35 @@ static inline uint64_t sysclkValidConfigValue(SysClkConfigValue val, uint64_t in { switch(val) { + case HocClkConfigValue_EristaMaxCpuClock: + case HocClkConfigValue_EristaMaxGpuClock: + case HocClkConfigValue_EristaMaxMemClock: + case HocClkConfigValue_MarikoMaxCpuClock: + case HocClkConfigValue_MarikoMaxGpuClock: + case HocClkConfigValue_MarikoMaxMemClock: + case HocClkConfigValue_EristaCpuBoostClock: + case HocClkConfigValue_MarikoCpuBoostClock: + case HocClkConfigValue_ThermalThrottleThreshold: + case HocClkConfigValue_HandheldTDPLimit: + case HocClkConfigValue_LiteTDPLimit: case SysClkConfigValue_PollingIntervalMs: return input > 0; case SysClkConfigValue_TempLogIntervalMs: case SysClkConfigValue_FreqLogIntervalMs: case SysClkConfigValue_PowerLogIntervalMs: case SysClkConfigValue_CsvWriteIntervalMs: + case HocClkConfigValue_EMCVdd2VoltageUV: + case HocClkConfigValue_EMCVdd2VoltageUVStockErista: + case HocClkConfigValue_EMCVdd2VoltageUVStockMariko: return input >= 0; - case HocClkConfigValue_OverwriteBoostMode: case HocClkConfigValue_UncappedClocks: - case HocClkConfigValue_SyncReverseNXMode: + case HocClkConfigValue_OverwriteBoostMode: + case HocClkConfigValue_ThermalThrottle: + case HocClkConfigValue_DockedGovernor: + case HocClkConfigValue_HandheldGovernor: + case HocClkConfigValue_HandheldTDP: + case HocClkConfigValue_EnforceBoardLimit: + case HocClkConfigValue_EMCDVFS: return (input & 0x1) == input; default: return false; diff --git a/Source/sys-clk/common/include/sysclk/errors.h b/Source/sys-clk/common/include/sysclk/errors.h index ed0d9a98..f6c88b75 100644 --- a/Source/sys-clk/common/include/sysclk/errors.h +++ b/Source/sys-clk/common/include/sysclk/errors.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #define SYSCLK_ERROR_MODULE 388 @@ -18,4 +35,5 @@ typedef enum SysClkError_Generic = 0, SysClkError_ConfigNotLoaded = 1, SysClkError_ConfigSaveFailed = 2, + HocClkError_SocThermFail = 3, } SysClkError; diff --git a/Source/sys-clk/common/include/sysclk/ipc.h b/Source/sys-clk/common/include/sysclk/ipc.h index 48437c8d..260f2b87 100644 --- a/Source/sys-clk/common/include/sysclk/ipc.h +++ b/Source/sys-clk/common/include/sysclk/ipc.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include @@ -15,7 +32,7 @@ #include "clock_manager.h" #define SYSCLK_IPC_API_VERSION 4 -#define SYSCLK_IPC_SERVICE_NAME "sys:clk" +#define SYSCLK_IPC_SERVICE_NAME "horizon:oc" enum SysClkIpcCmd { @@ -32,6 +49,7 @@ enum SysClkIpcCmd SysClkIpcCmd_SetConfigValues = 10, SysClkIpcCmd_GetFreqList = 11, SysClkIpcCmd_SetReverseNXRTMode = 12, + HocClkIpcCmd_UpdateEMCRegs = 13, }; diff --git a/Source/sys-clk/common/src/apm_profile_table.c b/Source/sys-clk/common/src/apm_profile_table.c index 23a95438..a01ed044 100644 --- a/Source/sys-clk/common/src/apm_profile_table.c +++ b/Source/sys-clk/common/src/apm_profile_table.c @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #include SysClkApmConfiguration sysclk_g_apm_configurations[] = { diff --git a/Source/sys-clk/common/src/client/ipc.c b/Source/sys-clk/common/src/client/ipc.c index 8bc6801a..c982759e 100644 --- a/Source/sys-clk/common/src/client/ipc.c +++ b/Source/sys-clk/common/src/client/ipc.c @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #define NX_SERVICE_ASSUME_NON_DOMAIN #include #include @@ -131,3 +148,9 @@ Result sysclkIpcSetReverseNXRTMode(ReverseNXMode mode) { return serviceDispatchIn(&g_sysclkSrv, SysClkIpcCmd_SetReverseNXRTMode, mode); } + +Result hocClkIpcUpdateEmcRegs() +{ + int nil = 0; + return serviceDispatchIn(&g_sysclkSrv, SysClkIpcCmd_SetReverseNXRTMode, nil); +} diff --git a/Source/sys-clk/manager/icon.jpg b/Source/sys-clk/manager/icon.jpg index f4e5135c..b771a68e 100644 Binary files a/Source/sys-clk/manager/icon.jpg and b/Source/sys-clk/manager/icon.jpg differ diff --git a/Source/sys-clk/manager/lib/borealis/library/include/borealis/view.hpp b/Source/sys-clk/manager/lib/borealis/library/include/borealis/view.hpp index 88f0980f..d1c53673 100644 --- a/Source/sys-clk/manager/lib/borealis/library/include/borealis/view.hpp +++ b/Source/sys-clk/manager/lib/borealis/library/include/borealis/view.hpp @@ -213,7 +213,7 @@ class View /** * Called each frame - * Do not override it to draw your view, + * Default it to draw your view, * override draw() instead */ virtual void frame(FrameContext* ctx); diff --git a/Source/sys-clk/manager/src/app_profiles_tab.cpp b/Source/sys-clk/manager/src/app_profiles_tab.cpp index 4c9bd48a..e36100b4 100644 --- a/Source/sys-clk/manager/src/app_profiles_tab.cpp +++ b/Source/sys-clk/manager/src/app_profiles_tab.cpp @@ -87,11 +87,11 @@ AppProfilesTab::AppProfilesTab() } // Name - if (!langEntry->name) - { - i++; - continue; - } + // if (!langEntry->name) + // { + // i++; + // continue; + // } Title* title = (Title*) malloc(sizeof(Title)); title->tid = tid; diff --git a/Source/sys-clk/manager/src/cheat_sheet_tab.cpp b/Source/sys-clk/manager/src/cheat_sheet_tab.cpp index 7e492770..c3a91f40 100644 --- a/Source/sys-clk/manager/src/cheat_sheet_tab.cpp +++ b/Source/sys-clk/manager/src/cheat_sheet_tab.cpp @@ -27,9 +27,17 @@ CheatSheetTab::CheatSheetTab() // CPU this->addView(new brls::Header("CPU Clocks")); brls::Table *cpuTable = new brls::Table(); + + cpuTable->addRow(brls::TableRowType::BODY, "Mariko Absolute Max", "2601 MHz"); + cpuTable->addRow(brls::TableRowType::BODY, "Mariko Unsafe Max", "2397 MHz"); - cpuTable->addRow(brls::TableRowType::BODY, "Maximum", "1785 MHz"); + cpuTable->addRow(brls::TableRowType::BODY, "Erista Absolute Max", "2295 MHz"); + + cpuTable->addRow(brls::TableRowType::BODY, "Erista Unsafe Max", "2091 MHz"); + cpuTable->addRow(brls::TableRowType::BODY, "Mariko Safe Max", "1963 MHz"); + cpuTable->addRow(brls::TableRowType::BODY, "Erista Safe Max", "1785 MHz"); cpuTable->addRow(brls::TableRowType::BODY, "Official Docked and Handheld", "1020 MHz"); + cpuTable->addRow(brls::TableRowType::BODY, "Sleep mode", "612 MHz"); this->addView(cpuTable); @@ -37,11 +45,22 @@ CheatSheetTab::CheatSheetTab() this->addView(new brls::Header("GPU Clocks")); brls::Table *gpuTable = new brls::Table(); - gpuTable->addRow(brls::TableRowType::BODY, "Maximum", "921 MHz"); + gpuTable->addRow(brls::TableRowType::BODY, "Mariko Absolute Max", "1536 MHz"); + + gpuTable->addRow(brls::TableRowType::BODY, "Mariko Unsafe Max", "1267 MHz"); + + gpuTable->addRow(brls::TableRowType::BODY, "Mariko Safe Max", "1152 MHz"); + gpuTable->addRow(brls::TableRowType::BODY, "Erista Absolute Max", "1075 MHz"); + + gpuTable->addRow(brls::TableRowType::BODY, "Erista Safe Max", "860 MHz"); + gpuTable->addRow(brls::TableRowType::BODY, "Official Docked", "768 MHz"); + gpuTable->addRow(brls::TableRowType::BODY, "Maximum Mariko Handheld", "614 MHz"); gpuTable->addRow(brls::TableRowType::BODY, "Maximum Erista Handheld", "460 MHz"); - gpuTable->addRow(brls::TableRowType::BODY, "Official Handheld", "384 MHz"); + + gpuTable->addRow(brls::TableRowType::BODY, "Official Handheld", "307-460 MHz"); + gpuTable->addRow(brls::TableRowType::BODY, "Boost Mode", "76 MHz"); this->addView(gpuTable); @@ -49,10 +68,48 @@ CheatSheetTab::CheatSheetTab() this->addView(new brls::Header("MEM Clocks")); brls::Table *memTable = new brls::Table(); - memTable->addRow(brls::TableRowType::BODY, "Maximum, Official Docked", "1600 MHz"); + memTable->addRow(brls::TableRowType::BODY, "Mariko 2133BL Max", "3500 MHz"); + + memTable->addRow(brls::TableRowType::BODY, "Mariko 1866BL Max", "3200 MHz"); + + memTable->addRow(brls::TableRowType::BODY, "Mariko 1600BL Max", "2900 MHz"); + + memTable->addRow(brls::TableRowType::BODY, "Mariko 1331BL Max", "2500 MHz"); + + memTable->addRow(brls::TableRowType::BODY, "Erista 2133BL Max", "2360 MHz"); + + memTable->addRow(brls::TableRowType::BODY, "Erista 1600BL Max", "2227 MHz"); + + memTable->addRow(brls::TableRowType::BODY, "Mariko 4266MT/s Safe Max", "2133 MHz"); + + memTable->addRow(brls::TableRowType::BODY, "Mariko 3766MT/s Safe Max", "1866 MHz"); + + memTable->addRow(brls::TableRowType::BODY, "Erista Unsafe Max", "1862 MHz"); + + memTable->addRow(brls::TableRowType::BODY, "Erista Safe Max", "1600 MHz"); + memTable->addRow(brls::TableRowType::BODY, "Official Handheld", "1331 MHz"); + memTable->addRow(brls::TableRowType::BODY, "Sleep Mode", "204 MHz"); + this->addView(memTable); + + this->addView(new brls::Header("Display Freqs")); + brls::Table *lcdTable = new brls::Table(); + + lcdTable->addRow(brls::TableRowType::BODY, "External Display (720P) Max", "240 HZ"); + + lcdTable->addRow(brls::TableRowType::BODY, "External Display (1080P) Max", "120 HZ"); + + lcdTable->addRow(brls::TableRowType::BODY, "OLED Max", "90 HZ"); + + lcdTable->addRow(brls::TableRowType::BODY, "LCD Max", "72 HZ"); + + lcdTable->addRow(brls::TableRowType::BODY, "Default", "60 HZ"); + + lcdTable->addRow(brls::TableRowType::BODY, "Minimum", "40 HZ"); + + this->addView(lcdTable); } void CheatSheetTab::customSpacing(brls::View* current, brls::View* next, int* spacing) diff --git a/Source/sys-clk/manager/src/logo.cpp b/Source/sys-clk/manager/src/logo.cpp index 5f4e0c02..e0b02d5c 100644 --- a/Source/sys-clk/manager/src/logo.cpp +++ b/Source/sys-clk/manager/src/logo.cpp @@ -21,7 +21,7 @@ #include "logo.h" Logo::Logo(LogoStyle style) { - this->logoLabel = new brls::Label(brls::LabelStyle::LIST_ITEM, "sys-clk", style == LogoStyle::ABOUT); + this->logoLabel = new brls::Label(brls::LabelStyle::LIST_ITEM, "Horizon OC", style == LogoStyle::ABOUT); this->logoLabel->setParent(this); int logoFont = brls::Application::findFont(LOGO_FONT_NAME); diff --git a/Source/sys-clk/manager/src/utils.h b/Source/sys-clk/manager/src/utils.h index dad9ef93..316fa5b2 100644 --- a/Source/sys-clk/manager/src/utils.h +++ b/Source/sys-clk/manager/src/utils.h @@ -33,7 +33,7 @@ extern uint32_t g_freq_table_hz[SysClkModule_EnumMax][SYSCLK_FREQ_LIST_MAX+1]; Result cacheFreqList(); std::string formatListItemTitle(const std::string str, size_t maxScore = 140); -brls::SelectListItem* createFreqListItem(SysClkModule module, uint32_t selectedFreqInMHz, std::string defaultString = "Do not override"); +brls::SelectListItem* createFreqListItem(SysClkModule module, uint32_t selectedFreqInMHz, std::string defaultString = "Default"); std::string formatFreq(uint32_t freq); std::string formatTid(uint64_t tid); diff --git a/Source/sys-clk/overlay/Makefile b/Source/sys-clk/overlay/Makefile index 346cc0d5..d5bab04f 100644 --- a/Source/sys-clk/overlay/Makefile +++ b/Source/sys-clk/overlay/Makefile @@ -37,7 +37,7 @@ include ${TOPDIR}/lib/libultrahand/ultrahand.mk # version control constants #--------------------------------------------------------------------------------- #TARGET_VERSION := $(shell git describe --dirty --always --tags) -APP_VERSION := 1.0.1 +APP_VERSION := 0.0.4 TARGET_VERSION := $(APP_VERSION) #--------------------------------------------------------------------------------- @@ -53,7 +53,7 @@ CFLAGS := -Os -Wall -flto -fdata-sections -ffunction-sections -fno-rtti -fno-com CFLAGS += $(INCLUDE) -D__SWITCH__ # Enable appearance overriding -UI_OVERRIDE_PATH := /config/sys-clk/ +UI_OVERRIDE_PATH := /config/horizon-oc/ CFLAGS += -DUI_OVERRIDE_PATH="\"$(UI_OVERRIDE_PATH)\"" # Disable fstream diff --git a/Source/sys-clk/overlay/lang/de.json b/Source/sys-clk/overlay/lang/de.json index f2f9af1d..ff105584 100644 --- a/Source/sys-clk/overlay/lang/de.json +++ b/Source/sys-clk/overlay/lang/de.json @@ -30,6 +30,6 @@ "PD Charger   Reset": "Offizielles Ladegerät   Reset", "USB Charger   Reset": "USB-Ladegerät   Reset", "Memory": "Speicher", - "Do not override": "Nicht überschreiben", + "Default": "Nicht überschreiben", "Profile": "Profil" } diff --git a/Source/sys-clk/overlay/lang/en.json b/Source/sys-clk/overlay/lang/en.json index 0168f6e8..a3ea6ac8 100644 --- a/Source/sys-clk/overlay/lang/en.json +++ b/Source/sys-clk/overlay/lang/en.json @@ -30,6 +30,6 @@ "PD Charger   Reset": "PD Charger   Reset", "USB Charger   Reset": "USB Charger   Reset", "Memory": "Memory", - "Do not override": "Do not overrride", + "Default": "Do not overrride", "Profile": "Profile" } diff --git a/Source/sys-clk/overlay/lang/es.json b/Source/sys-clk/overlay/lang/es.json index 0bff493c..b617839f 100644 --- a/Source/sys-clk/overlay/lang/es.json +++ b/Source/sys-clk/overlay/lang/es.json @@ -30,6 +30,6 @@ "PD Charger   Reset": "Cargador oficial   Reiniciar", "USB Charger   Reset": "Cargador USB   Reiniciar", "Memory": "Memoria", - "Do not override": "No sobrescribir", + "Default": "No sobrescribir", "Profile": "Perfil" } diff --git a/Source/sys-clk/overlay/lang/fr.json b/Source/sys-clk/overlay/lang/fr.json index fa5dc822..2098edb9 100644 --- a/Source/sys-clk/overlay/lang/fr.json +++ b/Source/sys-clk/overlay/lang/fr.json @@ -30,6 +30,6 @@ "PD Charger   Reset": "Chargeur off.   Réinitialiser", "USB Charger   Reset": "Chargeur USB   Réinitialiser", "Memory": "Mémoire", - "Do not override": "Ne pas remplacer", + "Default": "Ne pas remplacer", "Profile": "Profil" } diff --git a/Source/sys-clk/overlay/lang/it.json b/Source/sys-clk/overlay/lang/it.json index 09a0b891..52ae8be9 100644 --- a/Source/sys-clk/overlay/lang/it.json +++ b/Source/sys-clk/overlay/lang/it.json @@ -30,6 +30,6 @@ "PD Charger   Reset": "Caricatore ufficiale   Reimposta", "USB Charger   Reset": "Caricatore USB   Reimposta", "Memory": "Memoria", - "Do not override": "Non sovrascrivere", + "Default": "Non sovrascrivere", "Profile": "Profilo" } diff --git a/Source/sys-clk/overlay/lang/ja.json b/Source/sys-clk/overlay/lang/ja.json index c75eb047..b3e48afa 100644 --- a/Source/sys-clk/overlay/lang/ja.json +++ b/Source/sys-clk/overlay/lang/ja.json @@ -30,6 +30,6 @@ "PD Charger   Reset": "公式充電器   リセット", "USB Charger   Reset": "USB充電器   リセット", "Memory": "メモリ", - "Do not override": "オーバーライドしない", + "Default": "オーバーライドしない", "Profile": "プロフィール" } diff --git a/Source/sys-clk/overlay/lang/ko.json b/Source/sys-clk/overlay/lang/ko.json index 9bc03beb..880485f5 100644 --- a/Source/sys-clk/overlay/lang/ko.json +++ b/Source/sys-clk/overlay/lang/ko.json @@ -30,6 +30,6 @@ "PD Charger   Reset": "공식 충전기   리셋", "USB Charger   Reset": "USB 충전기   리셋", "Memory": "메모리", - "Do not override": "오버라이드 안 함", + "Default": "오버라이드 안 함", "Profile": "프로필" } diff --git a/Source/sys-clk/overlay/lang/nl.json b/Source/sys-clk/overlay/lang/nl.json index 0b6579ab..86945f25 100644 --- a/Source/sys-clk/overlay/lang/nl.json +++ b/Source/sys-clk/overlay/lang/nl.json @@ -30,6 +30,6 @@ "PD Charger   Reset": "Officiële oplader   Resetten", "USB Charger   Reset": "USB-oplader   Resetten", "Memory": "Geheugen", - "Do not override": "Niet overschrijven", + "Default": "Niet overschrijven", "Profile": "Profiel" } diff --git a/Source/sys-clk/overlay/lang/pl.json b/Source/sys-clk/overlay/lang/pl.json index fe0739cf..2a9d54ad 100644 --- a/Source/sys-clk/overlay/lang/pl.json +++ b/Source/sys-clk/overlay/lang/pl.json @@ -30,6 +30,6 @@ "PD Charger   Reset": "Oficjalna ładowarka   Resetuj", "USB Charger   Reset": "Ładowarka USB   Resetuj", "Memory": "Pamięć", - "Do not override": "Nie nadpisuj", + "Default": "Nie nadpisuj", "Profile": "Profil" } diff --git a/Source/sys-clk/overlay/lang/pt.json b/Source/sys-clk/overlay/lang/pt.json index 25e225a0..d442444b 100644 --- a/Source/sys-clk/overlay/lang/pt.json +++ b/Source/sys-clk/overlay/lang/pt.json @@ -30,6 +30,6 @@ "PD Charger   Reset": "Carreg. of.   Reiniciar", "USB Charger   Reset": "Carregador USB   Reiniciar", "Memory": "Memória", - "Do not override": "Não substituir", + "Default": "Não substituir", "Profile": "Perfil" } diff --git a/Source/sys-clk/overlay/lang/ru.json b/Source/sys-clk/overlay/lang/ru.json index 501b62f6..2d424157 100644 --- a/Source/sys-clk/overlay/lang/ru.json +++ b/Source/sys-clk/overlay/lang/ru.json @@ -30,6 +30,6 @@ "PD Charger   Reset": "Офиц. зарядка   Сброс", "USB Charger   Reset": "USB зарядка   Сброс", "Memory": "RAM", - "Do not override": "По умолчанию", + "Default": "По умолчанию", "Profile": "Профиль" } diff --git a/Source/sys-clk/overlay/lang/uk.json b/Source/sys-clk/overlay/lang/uk.json index ae08ce1d..313fe33d 100644 --- a/Source/sys-clk/overlay/lang/uk.json +++ b/Source/sys-clk/overlay/lang/uk.json @@ -30,6 +30,6 @@ "PD Charger   Reset": "Оф. зарядка   Скидання", "USB Charger   Reset": "USB зарядка   Скидання", "Memory": "Пам’ять", - "Do not override": "Не змінювати", + "Default": "Не змінювати", "Profile": "Профіль" } diff --git a/Source/sys-clk/overlay/lang/zh-cn.json b/Source/sys-clk/overlay/lang/zh-cn.json index e1487637..655ff113 100644 --- a/Source/sys-clk/overlay/lang/zh-cn.json +++ b/Source/sys-clk/overlay/lang/zh-cn.json @@ -30,6 +30,6 @@ "PD Charger   Reset": "官方充电器   重置", "USB Charger   Reset": "USB充电器   重置", "Memory": "内存", - "Do not override": "不覆盖", + "Default": "不覆盖", "Profile": "配置文件" } diff --git a/Source/sys-clk/overlay/lang/zh-tw.json b/Source/sys-clk/overlay/lang/zh-tw.json index 3bd6a25e..a68a66fe 100644 --- a/Source/sys-clk/overlay/lang/zh-tw.json +++ b/Source/sys-clk/overlay/lang/zh-tw.json @@ -30,6 +30,6 @@ "PD Charger   Reset": "官方充電器   重置", "USB Charger   Reset": "USB充電器   重置", "Memory": "記憶體", - "Do not override": "不覆蓋", + "Default": "不覆蓋", "Profile": "設定檔" } diff --git a/Source/sys-clk/overlay/lib/libultrahand/.pics/tmp b/Source/sys-clk/overlay/lib/libultrahand/.pics/tmp deleted file mode 100644 index 8b137891..00000000 --- a/Source/sys-clk/overlay/lib/libultrahand/.pics/tmp +++ /dev/null @@ -1 +0,0 @@ - diff --git a/Source/sys-clk/overlay/lib/libultrahand/README.md b/Source/sys-clk/overlay/lib/libultrahand/README.md index d7a78ce8..26492baa 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/README.md +++ b/Source/sys-clk/overlay/lib/libultrahand/README.md @@ -2,7 +2,7 @@ [![platform](https://img.shields.io/badge/platform-Switch-898c8c?logo=C++.svg)](https://gbatemp.net/forums/nintendo-switch.283/?prefix_id=44) [![language](https://img.shields.io/badge/language-C++-ba1632?logo=C++.svg)](https://github.com/topics/cpp) [![GPLv2 License](https://img.shields.io/badge/license-GPLv2-189c11.svg)](https://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html) -[![Latest Version](https://img.shields.io/github/v/release/ppkantorski/libultrahand?label=latest%20version&color=blue)](https://github.com/ppkantorski/libultrahand/releases/latest) +[![Latest Version](https://img.shields.io/github/v/release/ppkantorski/libultrahand?label=latest&color=blue)](https://github.com/ppkantorski/libultrahand/releases/latest) [![Downloads](https://img.shields.io/github/downloads/ppkantorski/libultrahand/total?color=6f42c1)](https://github.com/ppkantorski/libultrahand/graphs/traffic) [![GitHub issues](https://img.shields.io/github/issues/ppkantorski/libultrahand?color=222222)](https://github.com/ppkantorski/libultrahand/issues) [![GitHub stars](https://img.shields.io/github/stars/ppkantorski/libultrahand)](https://github.com/ppkantorski/libultrahand/stargazers) diff --git a/Source/sys-clk/overlay/lib/libultrahand/libtesla/include/tesla.hpp b/Source/sys-clk/overlay/lib/libultrahand/libtesla/include/tesla.hpp index fc5aba53..2bcc7b72 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libtesla/include/tesla.hpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libtesla/include/tesla.hpp @@ -48,7 +48,10 @@ #include #include +#if !IS_LAUNCHER_DIRECTIVE #include // unused, but preserved for projects that might need it +#endif + #include #include #include @@ -64,6 +67,7 @@ #include //#include + // Define this makro before including tesla.hpp in your main file. If you intend // to use the tesla.hpp header in more than one source file, only define it once! // #define TESLA_INIT_IMPL @@ -137,14 +141,20 @@ volatile bool delayUpdate = false; volatile bool pendingExit = false; volatile bool wasRendering = false; -LEvent renderingStopEvent = {0}; +LEvent renderingStopEvent; bool FullMode = true; bool deactivateOriginalFooter = false; //bool fontCache = true; bool disableJumpTo = false; // Check for mini/micro mode flags -bool isMiniOrMicroMode = false; +//bool isMiniOrMicroMode = false; +inline std::string lastMode; +inline std::set overlayModes = {"full", "mini", "micro", "fps_graph", "fps_counter", "game_resolutions"}; + +bool isValidOverlayMode() { + return overlayModes.count(lastMode) > 0; +} #endif @@ -173,7 +183,8 @@ inline std::atomic jumpItemExactMatch{true}; inline std::atomic s_onLeftPage{false}; inline std::atomic s_onRightPage{false}; -inline bool screenshotsAreDisabled = false; +inline std::atomic screenshotsAreDisabled{false}; +inline std::atomic screenshotsAreForceDisabled{false}; //#if IS_LAUNCHER_DIRECTIVE inline bool hideHidden = false; @@ -183,6 +194,42 @@ inline bool hideHidden = false; inline std::atomic mainComboHasTriggered{false}; inline std::atomic launchComboHasTriggered{false}; + + +// Sound triggering variables +inline std::atomic triggerNavigationSound{false}; +inline std::atomic triggerEnterSound{false}; +inline std::atomic triggerExitSound{false}; +inline std::atomic triggerWallSound{false}; +inline std::atomic triggerOnSound{false}; +inline std::atomic triggerOffSound{false}; +inline std::atomic triggerSettingsSound{false}; +inline std::atomic triggerMoveSound{false}; +inline std::atomic disableSound{false}; +//inline std::atomic clearSoundCacheNow{false}; +inline std::atomic reloadSoundCacheNow{false}; + +// Haptic triggering variables +inline std::atomic triggerRumbleClick{false}; +inline std::atomic triggerRumbleDoubleClick{false}; + + +static inline void triggerNavigationFeedback() { + triggerRumbleClick.store(true, std::memory_order_release); + triggerNavigationSound.store(true, std::memory_order_release); +} + +static inline void triggerEnterFeedback() { + triggerRumbleClick.store(true, std::memory_order_release); + triggerEnterSound.store(true, std::memory_order_release); +} + +static inline void triggerExitFeedback() { + triggerRumbleDoubleClick.store(true, std::memory_order_release); + triggerExitSound.store(true, std::memory_order_release); +} + + namespace tsl { // Booleans @@ -295,6 +342,7 @@ namespace tsl { static Color defaultBackgroundColor = RGB888(ult::blackColor, defaultBackgroundAlpha); static Color defaultTextColor = RGB888(ult::whiteColor); + static Color notificationTextColor = RGB888(ult::whiteColor); static Color headerTextColor = RGB888(ult::whiteColor); static Color headerSeparatorColor = RGB888(ult::whiteColor); static Color starColor = RGB888(ult::whiteColor); @@ -320,13 +368,13 @@ namespace tsl { static Color packageTextColor = RGB888(ult::whiteColor); static Color ultPackageTextColor = RGB888("9ed0ff"); - static Color bannerVersionTextColor = RGB888("AAAAAA"); - static Color overlayVersionTextColor = RGB888("AAAAAA"); + static Color bannerVersionTextColor = RGB888(ult::greyColor); + static Color overlayVersionTextColor = RGB888(ult::greyColor); static Color ultOverlayVersionTextColor = RGB888("00FFDD"); - static Color packageVersionTextColor = RGB888("AAAAAA"); + static Color packageVersionTextColor = RGB888(ult::greyColor); static Color ultPackageVersionTextColor = RGB888("00FFDD"); static Color onTextColor = RGB888("00FFDD"); - static Color offTextColor = RGB888("AAAAAA"); + static Color offTextColor = RGB888(ult::greyColor); #if IS_LAUNCHER_DIRECTIVE static Color dynamicLogoRGB1 = RGB888("00E669"); @@ -384,123 +432,99 @@ namespace tsl { static Color trackBarFullColor = RGB888("00FFDD"); static Color trackBarEmptyColor = RGB888("404040"); - static void initializeThemeVars() { // NOTE: This needs to be called once in your application. - // Fetch all theme settings at once from the INI file + static void initializeThemeVars() { auto themeData = ult::getParsedDataFromIniFile(ult::THEME_CONFIG_INI_PATH); - if (themeData.count(ult::THEME_STR) > 0) { - auto& themeSection = themeData[ult::THEME_STR]; - - // Fetch and process each theme setting using a helper to simplify fetching and fallback - auto getValue = [&](const std::string& key) { - return themeSection.count(key) ? themeSection[key] : ult::defaultThemeSettingsMap[key]; - }; - - // Convert hex color to Color and manage default values and conversion - auto getColor = [&](const std::string& key, size_t alpha = 15) { - //std::string hexColor = getValue(key); - return RGB888(getValue(key), alpha); - }; - - auto getAlpha = [&](const std::string& key) { - std::string alphaStr = getValue(key); - return !alphaStr.empty() ? ult::stoi(alphaStr) : ult::stoi(ult::defaultThemeSettingsMap[key]); - }; - - //disableColorfulLogo = (getValue("disable_colorful_logo") == ult::TRUE_STR); - - #if IS_LAUNCHER_DIRECTIVE - logoColor1 = getColor("logo_color_1"); - logoColor2 = getColor("logo_color_2"); - #endif - - defaultBackgroundAlpha = getAlpha("bg_alpha"); - defaultBackgroundColor = getColor("bg_color", defaultBackgroundAlpha); - defaultTextColor = getColor("text_color"); - headerTextColor = getColor("header_text_color"); - headerSeparatorColor = getColor("header_separator_color"); - starColor = getColor("star_color"); - selectionStarColor = getColor("selection_star_color"); - buttonColor = getColor("bottom_button_color"); - bottomTextColor = getColor("bottom_text_color"); - bottomSeparatorColor = getColor("bottom_separator_color"); - topSeparatorColor = getColor("top_separator_color"); - defaultOverlayColor = getColor("default_overlay_color"); - defaultPackageColor = getColor("default_package_color"); - defaultScriptColor = getColor("default_script_color"); - - clockColor = getColor("clock_color"); - temperatureColor = getColor("temperature_color"); - batteryColor = getColor("battery_color"); - batteryChargingColor = getColor("battery_charging_color"); - batteryLowColor = getColor("battery_low_color"); - widgetBackdropAlpha = getAlpha("widget_backdrop_alpha"); - widgetBackdropColor = getColor("widget_backdrop_color", widgetBackdropAlpha); - - overlayTextColor = getColor("overlay_text_color"); - ultOverlayTextColor = getColor("ult_overlay_text_color"); - packageTextColor = getColor("package_text_color"); - ultPackageTextColor = getColor("ult_package_text_color"); - - bannerVersionTextColor = getColor("banner_version_text_color"); - overlayVersionTextColor = getColor("overlay_version_text_color"); - ultOverlayVersionTextColor = getColor("ult_overlay_version_text_color"); - packageVersionTextColor =getColor("package_version_text_color"); - ultPackageVersionTextColor = getColor("ult_package_version_text_color"); - onTextColor = getColor("on_text_color"); - offTextColor = getColor("off_text_color"); - - #if IS_LAUNCHER_DIRECTIVE - dynamicLogoRGB1 = getColor("dynamic_logo_color_1"); - dynamicLogoRGB2 = getColor("dynamic_logo_color_2"); - #endif - - //disableSelectionBG = (getValue("disable_selection_bg") == ult::TRUE_STR); - //disableSelectionValueColor = (getValue("disable_selection_value_color") == ult::TRUE_STR); - invertBGClickColor = (getValue("invert_bg_click_color") == ult::TRUE_STR); - - selectionBGAlpha = getAlpha("selection_bg_alpha"); - selectionBGColor = getColor("selection_bg_color", selectionBGAlpha); - - highlightColor1 = getColor("highlight_color_1"); - highlightColor2 = getColor("highlight_color_2"); - highlightColor3 = getColor("highlight_color_3"); - highlightColor4 = getColor("highlight_color_4"); - - clickAlpha = getAlpha("click_alpha"); - clickColor = getColor("click_color", clickAlpha); - - progressAlpha = getAlpha("progress_alpha"); - progressColor = getColor("progress_color", progressAlpha); - - trackBarColor = getColor("trackbar_color"); - - separatorAlpha = getAlpha("separator_alpha"); - separatorColor = getColor("separator_color", separatorAlpha); - - textSeparatorColor = getColor("text_separator_color"); - - selectedTextColor = getColor("selection_text_color"); - selectedValueTextColor = getColor("selection_value_text_color"); - inprogressTextColor = getColor("inprogress_text_color"); - invalidTextColor = getColor("invalid_text_color"); - clickTextColor = getColor("click_text_color"); - - tableBGAlpha = getAlpha("table_bg_alpha"); - tableBGColor = getColor("table_bg_color", tableBGAlpha); - sectionTextColor = getColor("table_section_text_color"); - infoTextColor = getColor("table_info_text_color"); - warningTextColor = getColor("warning_text_color"); - - healthyRamTextColor = getColor("healthy_ram_text_color"); - neutralRamTextColor = getColor("neutral_ram_text_color"); - badRamTextColor = getColor("bad_ram_text_color"); - - trackBarSliderColor = getColor("trackbar_slider_color"); - trackBarSliderBorderColor = getColor("trackbar_slider_border_color"); - trackBarSliderMalleableColor = getColor("trackbar_slider_malleable_color"); - trackBarFullColor = getColor("trackbar_full_color"); - trackBarEmptyColor = getColor("trackbar_empty_color"); - } + if (themeData.count(ult::THEME_STR) == 0) return; + + auto& themeSection = themeData[ult::THEME_STR]; + + auto getValue = [&](const char* key) -> const std::string& { + auto it = themeSection.find(key); + return it != themeSection.end() ? it->second : ult::defaultThemeSettingsMap[key]; + }; + + auto getColor = [&](const char* key, size_t alpha = 15) { + return RGB888(getValue(key), alpha); + }; + + auto getAlpha = [&](const char* key) { + const auto& alphaStr = getValue(key); + return ult::stoi(alphaStr); + }; + + #if IS_LAUNCHER_DIRECTIVE + logoColor1 = getColor("logo_color_1"); + logoColor2 = getColor("logo_color_2"); + dynamicLogoRGB1 = getColor("dynamic_logo_color_1"); + dynamicLogoRGB2 = getColor("dynamic_logo_color_2"); + #endif + + defaultBackgroundAlpha = getAlpha("bg_alpha"); + defaultBackgroundColor = getColor("bg_color", defaultBackgroundAlpha); + defaultTextColor = getColor("text_color"); + notificationTextColor = getColor("notification_text_color"); + headerTextColor = getColor("header_text_color"); + headerSeparatorColor = getColor("header_separator_color"); + starColor = getColor("star_color"); + selectionStarColor = getColor("selection_star_color"); + buttonColor = getColor("bottom_button_color"); + bottomTextColor = getColor("bottom_text_color"); + bottomSeparatorColor = getColor("bottom_separator_color"); + topSeparatorColor = getColor("top_separator_color"); + defaultOverlayColor = getColor("default_overlay_color"); + defaultPackageColor = getColor("default_package_color"); + defaultScriptColor = getColor("default_script_color"); + clockColor = getColor("clock_color"); + temperatureColor = getColor("temperature_color"); + batteryColor = getColor("battery_color"); + batteryChargingColor = getColor("battery_charging_color"); + batteryLowColor = getColor("battery_low_color"); + widgetBackdropAlpha = getAlpha("widget_backdrop_alpha"); + widgetBackdropColor = getColor("widget_backdrop_color", widgetBackdropAlpha); + overlayTextColor = getColor("overlay_text_color"); + ultOverlayTextColor = getColor("ult_overlay_text_color"); + packageTextColor = getColor("package_text_color"); + ultPackageTextColor = getColor("ult_package_text_color"); + bannerVersionTextColor = getColor("banner_version_text_color"); + overlayVersionTextColor = getColor("overlay_version_text_color"); + ultOverlayVersionTextColor = getColor("ult_overlay_version_text_color"); + packageVersionTextColor = getColor("package_version_text_color"); + ultPackageVersionTextColor = getColor("ult_package_version_text_color"); + onTextColor = getColor("on_text_color"); + offTextColor = getColor("off_text_color"); + invertBGClickColor = (getValue("invert_bg_click_color") == ult::TRUE_STR); + selectionBGAlpha = getAlpha("selection_bg_alpha"); + selectionBGColor = getColor("selection_bg_color", selectionBGAlpha); + highlightColor1 = getColor("highlight_color_1"); + highlightColor2 = getColor("highlight_color_2"); + highlightColor3 = getColor("highlight_color_3"); + highlightColor4 = getColor("highlight_color_4"); + clickAlpha = getAlpha("click_alpha"); + clickColor = getColor("click_color", clickAlpha); + progressAlpha = getAlpha("progress_alpha"); + progressColor = getColor("progress_color", progressAlpha); + trackBarColor = getColor("trackbar_color"); + separatorAlpha = getAlpha("separator_alpha"); + separatorColor = getColor("separator_color", separatorAlpha); + textSeparatorColor = getColor("text_separator_color"); + selectedTextColor = getColor("selection_text_color"); + selectedValueTextColor = getColor("selection_value_text_color"); + inprogressTextColor = getColor("inprogress_text_color"); + invalidTextColor = getColor("invalid_text_color"); + clickTextColor = getColor("click_text_color"); + tableBGAlpha = getAlpha("table_bg_alpha"); + tableBGColor = getColor("table_bg_color", tableBGAlpha); + sectionTextColor = getColor("table_section_text_color"); + infoTextColor = getColor("table_info_text_color"); + warningTextColor = getColor("warning_text_color"); + healthyRamTextColor = getColor("healthy_ram_text_color"); + neutralRamTextColor = getColor("neutral_ram_text_color"); + badRamTextColor = getColor("bad_ram_text_color"); + trackBarSliderColor = getColor("trackbar_slider_color"); + trackBarSliderBorderColor = getColor("trackbar_slider_border_color"); + trackBarSliderMalleableColor = getColor("trackbar_slider_malleable_color"); + trackBarFullColor = getColor("trackbar_full_color"); + trackBarEmptyColor = getColor("trackbar_empty_color"); } #if !IS_LAUNCHER_DIRECTIVE @@ -557,6 +581,8 @@ namespace tsl { } else { ult::deleteFileOrDirectory(ult::NOTIFICATIONS_FLAG_FILEPATH); } + ult::useSoundEffects = getBoolValue("sound_effects", false); + ult::useHapticFeedback = getBoolValue("haptic_feedback", false); ult::useSwipeToOpen = getBoolValue("swipe_to_open", true); // TRUE_STR default ult::useOpaqueScreenshots = getBoolValue("opaque_screenshots", true); // TRUE_STR default @@ -924,8 +950,11 @@ namespace tsl { return result; } + inline static std::mutex comboMutex; + // Function to load key combo mappings from both overlays.ini and packages.ini static void loadEntryKeyCombos() { + std::lock_guard lock(comboMutex); ult::g_entryCombos.clear(); // Load overlay combos from overlays.ini @@ -980,6 +1009,7 @@ namespace tsl { // Function to check if a key combination matches any overlay key combo static OverlayCombo getEntryForKeyCombo(u64 keys) { + std::lock_guard lock(comboMutex); if (auto it = ult::g_entryCombos.find(keys); it != ult::g_entryCombos.end()) return it->second; return { "", "" }; @@ -1096,7 +1126,7 @@ namespace tsl { // Existing caches inline static std::unordered_map> s_sharedGlyphCache; - inline static std::unordered_map> s_persistentGlyphCache; + //inline static std::unordered_map> s_persistentGlyphCache; // NEW: Notification-specific cache inline static std::unordered_map> s_notificationGlyphCache; @@ -1168,9 +1198,9 @@ namespace tsl { case CacheType::Notification: targetCache = &s_notificationGlyphCache; break; - case CacheType::Persistent: - targetCache = &s_persistentGlyphCache; - break; + //case CacheType::Persistent: + // targetCache = &s_persistentGlyphCache; + // break; default: targetCache = &s_sharedGlyphCache; break; @@ -1190,12 +1220,12 @@ namespace tsl { // For notification cache, also check persistent cache (but not regular cache) // For regular cache, also check persistent cache (existing behavior) - if (cacheType != CacheType::Persistent) { - auto persistentIt = s_persistentGlyphCache.find(key); - if (persistentIt != s_persistentGlyphCache.end()) { - return persistentIt->second; - } - } + //if (cacheType != CacheType::Persistent) { + // auto persistentIt = s_persistentGlyphCache.find(key); + // if (persistentIt != s_persistentGlyphCache.end()) { + // return persistentIt->second; + // } + //} } // Glyph not found, need to create it with exclusive lock @@ -1210,12 +1240,12 @@ namespace tsl { } // Double-check persistent cache - if (cacheType != CacheType::Persistent) { - auto persistentIt = s_persistentGlyphCache.find(key); - if (persistentIt != s_persistentGlyphCache.end()) { - return persistentIt->second; - } - } + //if (cacheType != CacheType::Persistent) { + // auto persistentIt = s_persistentGlyphCache.find(key); + // if (persistentIt != s_persistentGlyphCache.end()) { + // return persistentIt->second; + // } + //} // Check cache size and cleanup if needed if (cacheType == CacheType::Regular && s_sharedGlyphCache.size() >= MAX_CACHE_SIZE) { @@ -1253,49 +1283,49 @@ namespace tsl { public: // NEW: Preload and persist specific characters - static void preloadPersistentGlyphs(const std::string& characters, u32 fontSize, bool monospace = false) { - std::unique_lock writeLock(s_cacheMutex); - - if (!s_initialized) return; - - // Convert UTF-8 string to UTF-32 codepoints - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - std::wstring_convert, char32_t> converter; - const std::u32string codepoints = converter.from_bytes(characters); - - #pragma GCC diagnostic pop - - s32 yAdvance; - for (char32_t character : codepoints) { - const u64 key = generateCacheKey(character, monospace, fontSize); - - if (s_persistentGlyphCache.find(key) != s_persistentGlyphCache.end()) { - continue; - } - - auto glyph = std::make_shared(); - glyph->currFont = selectFontForCharacterUnsafe(character); - if (!glyph->currFont) continue; - - glyph->currFontSize = stbtt_ScaleForPixelHeight(glyph->currFont, fontSize); - - stbtt_GetCodepointBitmapBoxSubpixel(glyph->currFont, character, - glyph->currFontSize, glyph->currFontSize, 0, 0, - &glyph->bounds[0], &glyph->bounds[1], &glyph->bounds[2], &glyph->bounds[3]); - - yAdvance = 0; - stbtt_GetCodepointHMetrics(glyph->currFont, monospace ? 'W' : character, - &glyph->xAdvance, &yAdvance); - - glyph->glyphBmp = stbtt_GetCodepointBitmap(glyph->currFont, - glyph->currFontSize, glyph->currFontSize, character, - &glyph->width, &glyph->height, nullptr, nullptr); - - s_persistentGlyphCache[key] = glyph; - } - } + //static void preloadPersistentGlyphs(const std::string& characters, u32 fontSize, bool monospace = false) { + // std::unique_lock writeLock(s_cacheMutex); + // + // if (!s_initialized) return; + // + // // Convert UTF-8 string to UTF-32 codepoints + // #pragma GCC diagnostic push + // #pragma GCC diagnostic ignored "-Wdeprecated-declarations" + // + // std::wstring_convert, char32_t> converter; + // const std::u32string codepoints = converter.from_bytes(characters); + // + // #pragma GCC diagnostic pop + // + // s32 yAdvance; + // for (char32_t character : codepoints) { + // const u64 key = generateCacheKey(character, monospace, fontSize); + // + // if (s_persistentGlyphCache.find(key) != s_persistentGlyphCache.end()) { + // continue; + // } + // + // auto glyph = std::make_shared(); + // glyph->currFont = selectFontForCharacterUnsafe(character); + // if (!glyph->currFont) continue; + // + // glyph->currFontSize = stbtt_ScaleForPixelHeight(glyph->currFont, fontSize); + // + // stbtt_GetCodepointBitmapBoxSubpixel(glyph->currFont, character, + // glyph->currFontSize, glyph->currFontSize, 0, 0, + // &glyph->bounds[0], &glyph->bounds[1], &glyph->bounds[2], &glyph->bounds[3]); + // + // yAdvance = 0; + // stbtt_GetCodepointHMetrics(glyph->currFont, monospace ? 'W' : character, + // &glyph->xAdvance, &yAdvance); + // + // glyph->glyphBmp = stbtt_GetCodepointBitmap(glyph->currFont, + // glyph->currFontSize, glyph->currFontSize, character, + // &glyph->width, &glyph->height, nullptr, nullptr); + // + // s_persistentGlyphCache[key] = glyph; + // } + //} static void initializeFonts(stbtt_fontinfo* stdFont, stbtt_fontinfo* localFont, @@ -1391,8 +1421,8 @@ namespace tsl { std::unique_lock cacheLock(s_cacheMutex); s_sharedGlyphCache.clear(); s_sharedGlyphCache.rehash(0); - s_persistentGlyphCache.clear(); - s_persistentGlyphCache.rehash(0); + //s_persistentGlyphCache.clear(); + //s_persistentGlyphCache.rehash(0); s_notificationGlyphCache.clear(); s_notificationGlyphCache.rehash(0); s_fontMetricsCache.clear(); @@ -1405,8 +1435,8 @@ namespace tsl { s_sharedGlyphCache.clear(); s_sharedGlyphCache.rehash(0); - s_persistentGlyphCache.clear(); - s_persistentGlyphCache.rehash(0); + //s_persistentGlyphCache.clear(); + //s_persistentGlyphCache.rehash(0); s_notificationGlyphCache.clear(); s_notificationGlyphCache.rehash(0); s_fontMetricsCache.clear(); @@ -1432,10 +1462,10 @@ namespace tsl { return s_initialized; } - static size_t getPersistentCacheSize() { - std::shared_lock lock(s_cacheMutex); - return s_persistentGlyphCache.size(); - } + //static size_t getPersistentCacheSize() { + // std::shared_lock lock(s_cacheMutex); + // return s_persistentGlyphCache.size(); + //} // NEW: Get notification cache size static size_t getNotificationCacheSize() { @@ -1457,12 +1487,12 @@ namespace tsl { } // Persistent cache - for (const auto& pair : s_persistentGlyphCache) { - const auto& glyph = pair.second; - if (glyph && glyph->glyphBmp) { - totalMemory += glyph->width * glyph->height; - } - } + //for (const auto& pair : s_persistentGlyphCache) { + // const auto& glyph = pair.second; + // if (glyph && glyph->glyphBmp) { + // totalMemory += glyph->width * glyph->height; + // } + //} // Notification cache for (const auto& pair : s_notificationGlyphCache) { @@ -1487,6 +1517,7 @@ namespace tsl { return s_stdFont; } }; + // Static member definitions //std::shared_mutex FontManager::s_cacheMutex; @@ -1513,18 +1544,8 @@ namespace tsl { if (translatedIt != ult::translationCache.end()) { text = translatedIt->second; } else { - // Need to upgrade to write lock - readLock.unlock(); - std::unique_lock writeLock(s_translationCacheMutex); - - // Double-check pattern - translatedIt = ult::translationCache.find(originalString); - if (translatedIt != ult::translationCache.end()) { - text = translatedIt->second; - } else { - ult::translationCache[originalString] = originalString; - text = originalString; - } + // Don't insert anything, just fallback to original string + text = originalString; } } #else @@ -2449,16 +2470,21 @@ namespace tsl { // Draw the row if (fullOpacity) { - // Use setPixel for full opacity for (x_curr = row_start; x_curr < row_end; ++x_curr) { - //this->setPixel(x_curr, y_curr, color); - //const u32 pixel_offset = this->getPixelOffset(x, y); - this->setPixelAtOffset(this->getPixelOffset(x_curr, y_curr), color); + + const u32 offset = this->getPixelOffset((u32)x_curr, (u32)y_curr); + if (offset == UINT32_MAX) continue; + + this->setPixelAtOffset(offset, color); } } else { - // Blended drawing for (x_curr = row_start; x_curr < row_end; ++x_curr) { - this->setPixelBlendDst(x_curr, y_curr, color); + + const u32 offset = this->getPixelOffset((u32)x_curr, (u32)y_curr); + if (offset == UINT32_MAX) continue; + + // you can keep using the existing blended helper which already checks UINT32_MAX + this->setPixelBlendDst((u32)x_curr, (u32)y_curr, color); } } } @@ -2490,98 +2516,6 @@ namespace tsl { 0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255 }; -// inline void processBMPChunk(const s32 x, const s32 y, const s32 screenW, const u8 *preprocessedData, -// const s32 startRow, const s32 endRow) { -// const s32 bytesPerRow = screenW * 2; -// const s32 endX16 = screenW & ~15; -// -// // Pre-declare all variables outside loops to avoid repeated allocations -// const u8 *rowPtr; -// s32 baseY; -// s32 x1; -// const u8* ptr; -// uint8x16x2_t packed; -// uint8x16_t high1, low1, high2, low2; -// uint8x16_t red, green, blue, alpha; -// alignas(16) u8 red_vals[16], green_vals[16], blue_vals[16], alpha_vals[16]; -// s32 baseX; -// s32 pixelX; -// u32 offset; -// Color color = {0}, src = {0}, end = {0}; -// const u16* framebuffer; -// u8 p1, p2; -// -// for (s32 y1 = startRow; y1 < endRow; ++y1) { -// rowPtr = preprocessedData + (y1 * bytesPerRow); -// baseY = y + y1; -// -// x1 = 0; -// -// // SIMD processing for 16 pixels at once -// for (; x1 < endX16; x1 += 16) { -// ptr = rowPtr + (x1 << 1); -// packed = vld2q_u8(ptr); -// -// // Expand 4-bit to 8-bit values -// high1 = vshrq_n_u8(packed.val[0], 4); -// low1 = vandq_u8(packed.val[0], mask_low); -// high2 = vshrq_n_u8(packed.val[1], 4); -// low2 = vandq_u8(packed.val[1], mask_low); -// -// red = vqtbl1q_u8(lut, high1); -// green = vqtbl1q_u8(lut, low1); -// blue = vqtbl1q_u8(lut, high2); -// alpha = vqtbl1q_u8(lut, low2); -// -// // Store to arrays and process individually -// vst1q_u8(red_vals, red); -// vst1q_u8(green_vals, green); -// vst1q_u8(blue_vals, blue); -// vst1q_u8(alpha_vals, alpha); -// -// baseX = x + x1; -// -// // Process 16 pixels with minimal function call overhead -// for (int i = 0; i < 16; ++i) { -// // Skip transparent pixels -// if (alpha_vals[i] == 0) continue; -// -// pixelX = baseX + i; -// offset = this->getPixelOffset(pixelX, baseY); -// -// if (offset != UINT32_MAX) { -// color = {red_vals[i], green_vals[i], blue_vals[i], alpha_vals[i]}; -// -// framebuffer = static_cast(this->getCurrentFramebuffer()); -// src = Color(framebuffer[offset]); -// -// end = { -// blendColor(src.r, color.r, color.a), -// blendColor(src.g, color.g, color.a), -// blendColor(src.b, color.b, color.a), -// src.a -// }; -// -// this->setPixelAtOffset(offset, end); -// } -// } -// } -// -// // Handle remaining pixels (less than 16) -// for (; x1 < screenW; ++x1) { -// p1 = rowPtr[x1 << 1]; -// p2 = rowPtr[(x1 << 1) + 1]; -// -// setPixelBlendSrc(x + x1, baseY, { -// expand4to8[p1 >> 4], expand4to8[p1 & 0x0F], -// expand4to8[p2 >> 4], expand4to8[p2 & 0x0F] -// }); -// } -// } -// -// ult::inPlotBarrier.arrive_and_wait(); -// } - inline void processBMPChunk(const s32 x, const s32 y, const s32 screenW, const u8 *preprocessedData, const s32 startRow, const s32 endRow, const u8 globalAlphaLimit) { @@ -2904,20 +2838,11 @@ namespace tsl { this->fillScreen(Color(0x0, 0x0, 0x0, 0x0)); // Fully transparent } - //struct Glyph { - // stbtt_fontinfo *currFont; - // float currFontSize; - // int bounds[4]; - // int xAdvance; - // u8 *glyphBmp; - // int width, height; - //}; - const stbtt_fontinfo& getStandardFont() const { return m_stdFont; } - + // Optimized unified drawString method with thread safety inline std::pair drawString(const std::string& originalString, bool monospace, const s32 x, const s32 y, const u32 fontSize, @@ -2931,25 +2856,15 @@ namespace tsl { // Thread-safe translation cache access std::string text; - #ifdef UI_OVERRIDE_PATH + #if defined(UI_OVERRIDE_PATH)// && (!defined(IS_STATUS_MONITOR) || (IS_STATUS_MONITOR == 0)) { std::shared_lock readLock(s_translationCacheMutex); auto translatedIt = ult::translationCache.find(originalString); if (translatedIt != ult::translationCache.end()) { text = translatedIt->second; } else { - // Need to upgrade to write lock - readLock.unlock(); - std::unique_lock writeLock(s_translationCacheMutex); - - // Double-check pattern - translatedIt = ult::translationCache.find(originalString); - if (translatedIt != ult::translationCache.end()) { - text = translatedIt->second; - } else { - ult::translationCache[originalString] = originalString; - text = originalString; - } + // Don't insert anything, just fallback to original string + text = originalString; } } #else @@ -3195,18 +3110,8 @@ namespace tsl { if (translatedIt != ult::translationCache.end()) { text = translatedIt->second; } else { - // Need to upgrade to write lock - readLock.unlock(); - std::unique_lock writeLock(s_translationCacheMutex); - - // Double-check pattern - translatedIt = ult::translationCache.find(originalString); - if (translatedIt != ult::translationCache.end()) { - text = translatedIt->second; - } else { - ult::translationCache[originalString] = originalString; - text = originalString; - } + // Don't insert anything, just fallback to original string + text = originalString; } } #else @@ -3335,29 +3240,6 @@ namespace tsl { return get(); } - //inline void setLayerPosImpl(u32 x, u32 y) { - // // Get the underscan pixel values for both horizontal and vertical borders - // const auto [horizontalUnderscanPixels, verticalUnderscanPixels] = getUnderscanPixels(); - // //int horizontalUnderscanPixels = 0; - // - // //ult::useRightAlignment = (ult::parseValueFromIniSection(ult::ULTRAHAND_CONFIG_INI_PATH, ult::ULTRAHAND_PROJECT_NAME, "right_alignment") == ult::TRUE_STR); - // //cfg::LayerPosX = 1280-32; - // cfg::LayerPosX = 0; - // cfg::LayerPosY = 0; - // cfg::FramebufferWidth = ult::DefaultFramebufferWidth; - // cfg::FramebufferHeight = ult::DefaultFramebufferHeight; - // - // //ult::correctFrameSize = (cfg::FramebufferWidth == 448 && cfg::FramebufferHeight == 720); // for detecting the correct Overlay display size - // if (ult::useRightAlignment && ult::correctFrameSize) { - // cfg::LayerPosX = 1280-32 - horizontalUnderscanPixels; - // ult::layerEdge = (1280-448); - // } - // - // cfg::LayerPosX += x; - // cfg::LayerPosY += y; - // ASSERT_FATAL(viSetLayerPosition(&this->m_layer, cfg::LayerPosX, cfg::LayerPosY)); - //} - inline void setLayerPosImpl(u32 x, u32 y) { // Get the underscan pixel values for both horizontal and vertical borders //const auto [horizontalUnderscanPixels, verticalUnderscanPixels] = getUnderscanPixels(); @@ -3642,19 +3524,23 @@ namespace tsl { /** * @brief Adds the layer from screenshot and recording stacks */ - inline void addScreenshotStacks() { - ASSERT_FATAL(tsl::hlp::viAddToLayerStack(&this->m_layer, ViLayerStack_Screenshot)); - ASSERT_FATAL(tsl::hlp::viAddToLayerStack(&this->m_layer, ViLayerStack_Recording)); - screenshotsAreDisabled = false; + inline void addScreenshotStacks(bool forceDisable = true) { + tsl::hlp::viAddToLayerStack(&this->m_layer, ViLayerStack_Screenshot); + tsl::hlp::viAddToLayerStack(&this->m_layer, ViLayerStack_Recording); + screenshotsAreDisabled.store(false, std::memory_order_release); + if (forceDisable) + screenshotsAreForceDisabled.store(false, std::memory_order_release); } /** * @brief Removes the layer from screenshot and recording stacks */ - inline void removeScreenshotStacks() { - ASSERT_FATAL(tsl::hlp::viRemoveFromLayerStack(&this->m_layer, ViLayerStack_Screenshot)); - ASSERT_FATAL(tsl::hlp::viRemoveFromLayerStack(&this->m_layer, ViLayerStack_Recording)); - screenshotsAreDisabled = true; + inline void removeScreenshotStacks(bool forceDisable = true) { + tsl::hlp::viRemoveFromLayerStack(&this->m_layer, ViLayerStack_Screenshot); + tsl::hlp::viRemoveFromLayerStack(&this->m_layer, ViLayerStack_Recording); + screenshotsAreDisabled.store(true, std::memory_order_release); + if (forceDisable) + screenshotsAreForceDisabled.store(true, std::memory_order_release); } private: @@ -3769,46 +3655,9 @@ namespace tsl { } } - // Replace divisions and modulos with bit operations - EXACT same logic - //return ((((y & 127) >> 4) + ((x >> 5) << 3) + ((y >> 7) * 112)) << 9) + // *512 = <<9 - // (((y & 15) >> 3) << 8) + // ((y % 16) / 8) * 256 - // (((x & 31) >> 4) << 7) + // ((x % 32) / 16) * 128 - // (((y & 7) >> 1) << 5) + // ((y % 8) / 2) * 32 - // (((x & 15) >> 3) << 4) + // ((x % 16) / 8) * 16 - // ((y & 1) << 3) + // (y % 2) * 8 - // (x & 7); // x % 8 - - //return ((((y & 127) >> 4) + ((x >> 5) << 3) + ((y >> 7) * (((cfg::FramebufferWidth / 2) >> 4) << 3))) << 9) + // *512 = <<9 - // (((y & 15) >> 3) << 8) + // ((y % 16) / 8) * 256 - // (((x & 31) >> 4) << 7) + // ((x % 32) / 16) * 128 - // (((y & 7) >> 1) << 5) + // ((y % 8) / 2) * 32 - // (((x & 15) >> 3) << 4) + // ((x % 16) / 8) * 16 - // ((y & 1) << 3) + // (y % 2) * 8 - // (x & 7); // x % 8 - - //return ((((y & 127) >> 4) + ((x >> 5) << 3) + ((y >> 7) * offsetWidthVar)) << 9) + // *512 = <<9 - // (((y & 15) >> 3) << 8) + // ((y % 16) / 8) * 256 - // (((x & 31) >> 4) << 7) + // ((x % 32) / 16) * 128 - // (((y & 7) >> 1) << 5) + // ((y % 8) / 2) * 32 - // (((x & 15) >> 3) << 4) + // ((x % 16) / 8) * 16 - // ((y & 1) << 3) + // (y % 2) * 8 - // (x & 7); // x % 8 - return ((((y & 127) >> 4) + ((x >> 5) << 3) + ((y >> 7) * offsetWidthVar)) << 9) + ((y & 8) << 5) + ((x & 16) << 3) + ((y & 6) << 4) + ((x & 8) << 1) + ((y & 1) << 3) + (x & 7); - - //const u32 y_hi = y >> 7; - //const u32 y_mid = (y >> 4) & 7; // bits 4-6 of y - //const u32 y_lo = y & 15; // bits 0-3 of y - // - //const u32 x_hi = x >> 5; // bits 5+ of x - //const u32 x_lo = x & 31; // bits 0-4 of x - // - //return ((y_mid + (x_hi << 3) + (y_hi * offsetWidthVar)) << 9) + - // ((y_lo >> 3) << 8) + ((x_lo >> 4) << 7) + - // (((y_lo & 7) >> 1) << 5) + (((x_lo & 15) >> 3) << 4) + - // ((y_lo & 1) << 3) + (x_lo & 7); } @@ -3927,7 +3776,7 @@ namespace tsl { * @return Result */ Result initFonts() { - static PlFontData stdFontData, localFontData, extFontData; + PlFontData stdFontData, localFontData, extFontData; // Nintendo's default font TSL_R_TRY(plGetSharedFontByType(&stdFontData, PlSharedFontType_Standard)); @@ -3991,29 +3840,29 @@ namespace tsl { * @warning Don't call this before calling \ref startFrame once */ inline void endFrame() { - #if IS_STATUS_MONITOR_DIRECTIVE - // Check if rendering is active by testing if the stop event is NOT signaled - if (isRendering) { // Returns true if event is signaled - memcpy(this->getNextFramebuffer(), this->getCurrentFramebuffer(), this->getFramebufferSize()); - + #if IS_STATUS_MONITOR_DIRECTIVE + if (isRendering) { static u32 lastFPS = 0; - static u64 cachedIntervalNs = 0; - - if (__builtin_expect(TeslaFPS != lastFPS, 0)) { // Hint: FPS changes are rare - cachedIntervalNs = 1000*1000*1000ULL / TeslaFPS; - lastFPS = TeslaFPS; + static u64 cachedIntervalNs = 1000000000ULL / 60; // Default to 60 FPS + + u32 fps = TeslaFPS; + if (__builtin_expect(fps != lastFPS, 0)) { + cachedIntervalNs = (fps > 0) ? (1000000000ULL / fps) : cachedIntervalNs; + lastFPS = fps; } - - // Wait for frame interval or rendering stop event + + // Frame pacing before VSync leventWait(&renderingStopEvent, cachedIntervalNs); } - #endif + #endif + + // Then hardware sync this->waitForVSync(); framebufferEnd(&this->m_framebuffer); this->m_currentFramebuffer = nullptr; - if (tsl::clearGlyphCacheNow.load(std::memory_order_acquire)) { - tsl::clearGlyphCacheNow.store(false, std::memory_order_release); - tsl::gfx::FontManager::clearCache(); // exclusive clear + + if (tsl::clearGlyphCacheNow.exchange(false)) { + tsl::gfx::FontManager::clearCache(); } } @@ -4214,6 +4063,10 @@ namespace tsl { this->m_highlightShaking = true; this->m_highlightShakingDirection = direction; this->m_highlightShakingStartTime = armTicksToNs(armGetSystemTick()); // Changed + if (direction != FocusDirection::None && m_isItem) { + triggerRumbleClick.store(true, std::memory_order_release); + triggerWallSound.store(true, std::memory_order_release); + } } /** @@ -4437,14 +4290,6 @@ namespace tsl { #if IS_LAUNCHER_DIRECTIVE // Determine the active percentage to use - //float activePercentage = 0.0f; - //if (ult::downloadPercentage > 0) { - // activePercentage = ult::downloadPercentage; - //} else if (ult::unzipPercentage > 0) { - // activePercentage = ult::unzipPercentage; - //} else if (ult::copyPercentage > 0) { - // activePercentage = ult::copyPercentage; - //} const float activePercentage = ult::displayPercentage.load(std::memory_order_acquire); if (activePercentage > 0){ if (ult::expandedMemory) @@ -4604,38 +4449,6 @@ namespace tsl { std::function m_clickListener = [](u64) { return false; }; }; - //static std::vector m_lastFrameItems; // for smooth handling of jumpToItem navigation - //static bool m_hasValidFrame = false; - //static float m_lastFrameOffset = 0.0f; - // Static cache with instance validation - - //#if IS_STATUS_MONITOR_DIRECTIVE - // /** - // * @brief A Element that exposes the renderer directly to draw custom views easily - // */ - // class CustomDrawer : public Element { - // public: - // /** - // * @brief Constructor - // * @note This element should only be used to draw static things the user cannot interact with e.g info text, images, etc. - // * - // * @param renderFunc Callback that will be called once every frame to draw this view - // */ - // CustomDrawer(std::function renderFunc) : Element(), m_renderFunc(renderFunc) {} - // virtual ~CustomDrawer() { - // m_isTable = true; - // } - // - // virtual void draw(gfx::Renderer* renderer) override { - // this->m_renderFunc(renderer, this->getX(), this->getY(), this->getWidth(), this->getHeight()); - // } - // - // virtual void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {} - // - // private: - // std::function m_renderFunc; - // }; - //#else /** * @brief A Element that exposes the renderer directly to draw custom views easily */ @@ -4712,7 +4525,119 @@ namespace tsl { bool isScrollable = false; }; + + #if IS_LAUNCHER_DIRECTIVE + // Simple utility function to draw the dynamic "Ultra" part of the logo + static s32 drawDynamicUltraText(gfx::Renderer* renderer, s32 startX, s32 y, u32 fontSize, + const tsl::Color& staticColor, bool useNotificationMethod = false) { + static constexpr double cycleDuration = 1.6; + s32 currentX = startX; + + if (ult::useDynamicLogo) { + const u64 currentTime_ns = armTicksToNs(armGetSystemTick()); + const double currentTimeCount = static_cast(currentTime_ns) / 1000000000.0; + const double timeBase = std::fmod(currentTimeCount, cycleDuration); + const double waveScale = 2.0 * ult::_M_PI / cycleDuration; + static constexpr double phaseShift = ult::_M_PI / 2.0; + float countOffset = 0; + for (const char letter : ult::SPLIT_PROJECT_NAME_1) { + const double wavePhase = waveScale * (timeBase + static_cast(countOffset)); + const double rawProgress = std::cos(wavePhase - phaseShift); + + const double normalizedProgress = (rawProgress + 1.0) * 0.5; + const double smoothedProgress = normalizedProgress * normalizedProgress * (3.0 - 2.0 * normalizedProgress); + const double ultraSmoothProgress = smoothedProgress * smoothedProgress * (3.0 - 2.0 * smoothedProgress); + + const double blend = std::max(0.0, std::min(1.0, ultraSmoothProgress)); + + const tsl::Color highlightColor = { + static_cast(dynamicLogoRGB1.r + (dynamicLogoRGB2.r - dynamicLogoRGB1.r) * blend + 0.5), + static_cast(dynamicLogoRGB1.g + (dynamicLogoRGB2.g - dynamicLogoRGB1.g) * blend + 0.5), + static_cast(dynamicLogoRGB1.b + (dynamicLogoRGB2.b - dynamicLogoRGB1.b) * blend + 0.5), + 15 + }; + + const std::string letterStr(1, letter); + if (useNotificationMethod) { + //const auto [letterWidth, letterHeight] = renderer->drawNotificationString(letterStr, false, currentX, y, fontSize, highlightColor); + currentX += renderer->drawNotificationString(letterStr, false, currentX, y, fontSize, highlightColor).first; + } else { + currentX += renderer->drawString(letterStr, false, currentX, y, fontSize, highlightColor).first; + } + countOffset -= static_cast(cycleDuration / 8.0); + } + } else { + // Static rendering + for (const char letter : ult::SPLIT_PROJECT_NAME_1) { + const std::string letterStr(1, letter); + if (useNotificationMethod) { + //const auto [letterWidth, letterHeight] = renderer->drawNotificationString(letterStr, false, currentX, y, fontSize, staticColor); + currentX += renderer->drawNotificationString(letterStr, false, currentX, y, fontSize, staticColor).first; + } else { + currentX += renderer->drawString(letterStr, false, currentX, y, fontSize, staticColor).first; + } + } + } + + return currentX; + } + + // Utility function to calculate width of the Ultra text (for notification centering) + static s32 calculateUltraTextWidth(gfx::Renderer* renderer, u32 fontSize, bool useNotificationMethod = false) { + s32 totalWidth = 0; + + if (ult::useDynamicLogo) { + // Calculate width by measuring each character for dynamic rendering + for (const char letter : ult::SPLIT_PROJECT_NAME_1) { + const std::string letterStr(1, letter); + if (useNotificationMethod) { + //const auto [lw, lh] = renderer->getNotificationTextDimensions(letterStr, false, fontSize); + totalWidth += renderer->getNotificationTextDimensions(letterStr, false, fontSize).first; + } else { + //const auto [lw, lh] = renderer->getTextDimensions(letterStr, false, fontSize); + totalWidth += renderer->getTextDimensions(letterStr, false, fontSize).first; + } + } + } else { + // Static rendering - measure the whole string at once + if (useNotificationMethod) { + //const auto [uw, uh] = renderer->getNotificationTextDimensions(ult::SPLIT_PROJECT_NAME_1, false, fontSize); + totalWidth = renderer->getNotificationTextDimensions(ult::SPLIT_PROJECT_NAME_1, false, fontSize).first; + } else { + //const auto [uw, uh] = renderer->getTextDimensions(ult::SPLIT_PROJECT_NAME_1, false, fontSize); + totalWidth = renderer->getTextDimensions(ult::SPLIT_PROJECT_NAME_1, false, fontSize).first; + } + } + + return totalWidth; + } + + #endif + + struct TopCache { + std::string title; + std::string subtitle; + tsl::Color titleColor{0xF, 0xF, 0xF, 0xF}; // white by default + bool widgetDrawn = false; + bool useDynamicLogo = false; + bool disabled = false; + }; + + struct BottomCache { + std::string bottomText; + float backWidth = 0.0f; + float selectWidth = 0.0f; + float nextPageWidth = 0.0f; + bool disabled = false; + }; + + // Global or namespace-level variable + inline TopCache g_cachedTop; + inline BottomCache g_cachedBottom; + + inline std::atomic g_disableMenuCacheOnReturn = false; + /** * @brief The base frame which can contain another view * @@ -4736,12 +4661,8 @@ namespace tsl { std::string m_pageLeftName; // CUSTOM MODIFICATION std::string m_pageRightName; // CUSTOM MODIFICATION - + tsl::Color titleColor = {0xF,0xF,0xF,0xF}; - static constexpr double cycleDuration = 1.6; - float counter = 0; - float countOffset; - float progress; float letterWidth; #endif @@ -4763,10 +4684,17 @@ namespace tsl { ult::activeHeaderHeight = 97; ult::loadWallpaperFileWhenSafe(); m_isItem = false; + disableSound.store(false, std::memory_order_release); } ~OverlayFrame() { delete m_contentElement; + + // Check if returning from a list that disabled caching + if (g_disableMenuCacheOnReturn.exchange(false, std::memory_order_acq_rel)) { + g_cachedTop.disabled = true; + g_cachedBottom.disabled = true; + } } #if USING_FPS_INDICATOR_DIRECTIVE @@ -4790,12 +4718,11 @@ namespace tsl { // CUSTOM SECTION START void draw(gfx::Renderer *renderer) override { - if (!ult::themeIsInitialized.load(std::memory_order_acquire)) { - ult::themeIsInitialized.store(true, std::memory_order_release); + if (!ult::themeIsInitialized.exchange(true, std::memory_order_acq_rel)) { tsl::initializeThemeVars(); } - + renderer->fillScreen(a(defaultBackgroundColor)); renderer->drawWallpaper(); @@ -4804,21 +4731,41 @@ namespace tsl { #if IS_LAUNCHER_DIRECTIVE // Current interpreter state (atomic) - const bool interpreterIsRunningNow = ult::runningInterpreter.load(std::memory_order_acquire) && (ult::downloadPercentage.load(std::memory_order_acquire) != -1 || ult::unzipPercentage.load(std::memory_order_acquire) != -1 || ult::copyPercentage.load(std::memory_order_acquire) != -1) ; + const bool interpreterIsRunningNow = ult::runningInterpreter.load(std::memory_order_acquire) && (ult::downloadPercentage.load(std::memory_order_acquire) != -1 || ult::unzipPercentage.load(std::memory_order_acquire) != -1 || ult::copyPercentage.load(std::memory_order_acquire) != -1); - if (m_noClickableItems != ult::noClickableItems.load(std::memory_order_acquire)) { ult::noClickableItems.store(m_noClickableItems, std::memory_order_release); } - + const bool isUltrahandMenu = (m_title == ult::CAPITAL_ULTRAHAND_PROJECT_NAME && m_subtitle.find("Ultrahand Package") == std::string::npos && m_subtitle.find("Ultrahand Script") == std::string::npos); - if (isUltrahandMenu) { - #if USING_WIDGET_DIRECTIVE - renderer->drawWidget(); - #endif + // Determine if we should use cached data (first frame of new overlay) + const bool useCachedTop = !g_cachedTop.disabled && + !g_cachedTop.title.empty() && + (g_cachedTop.title != m_title || g_cachedTop.subtitle != m_subtitle); + + // Use cached or current data for rendering + const std::string& renderTitle = useCachedTop ? g_cachedTop.title : m_title; + const std::string& renderSubtitle = useCachedTop ? g_cachedTop.subtitle : m_subtitle; + const tsl::Color& renderTitleColor = useCachedTop ? g_cachedTop.titleColor : titleColor; + const bool renderUseDynamicLogo = useCachedTop ? g_cachedTop.useDynamicLogo : ult::useDynamicLogo; + + const bool renderIsUltrahandMenu = (renderTitle == ult::CAPITAL_ULTRAHAND_PROJECT_NAME && + renderSubtitle.find("Ultrahand Package") == std::string::npos && + renderSubtitle.find("Ultrahand Script") == std::string::npos); + + if (renderIsUltrahandMenu) { + #if USING_WIDGET_DIRECTIVE + if (useCachedTop) { + if (g_cachedTop.widgetDrawn) { + renderer->drawWidget(); + } + } else { + renderer->drawWidget(); + } + #endif if (ult::touchingMenu.load(std::memory_order_acquire) && ult::inMainMenu.load(std::memory_order_acquire)) { renderer->drawRoundedRect(0.0f + 7, 12.0f, 245.0f - 13, 73.0f, 10.0f, a(clickColor)); @@ -4827,194 +4774,189 @@ namespace tsl { x = 20; fontSize = 42; offset = 6; - countOffset = 0; - - if (ult::useDynamicLogo) { - const u64 currentTime_ns = armTicksToNs(armGetSystemTick()); - - // High precision time calculation to prevent stepping artifacts - const double currentTimeCount = static_cast(currentTime_ns) / 1000000000.0; - - // Pre-calculate time base once per frame for consistent wave sync - const double timeBase = std::fmod(currentTimeCount, cycleDuration); - - // Pre-calculate wave constants - NOW MATCHES CYCLE DURATION - const double waveScale = 2.0 * ult::_M_PI / cycleDuration; - static constexpr double phaseShift = ult::_M_PI / 2.0; - - for (const char letter : ult::SPLIT_PROJECT_NAME_1) { - // Smooth, precise wave calculation - const double wavePhase = waveScale * (timeBase + static_cast(countOffset)); - const double rawProgress = std::cos(wavePhase - phaseShift); - - // Apply double smoothstep for ultra-smooth color transitions - const double normalizedProgress = (rawProgress + 1.0) * 0.5; // Convert to 0-1 - const double smoothedProgress = normalizedProgress * normalizedProgress * (3.0 - 2.0 * normalizedProgress); - // Apply smoothstep again for even smoother transitions - const double ultraSmoothProgress = smoothedProgress * smoothedProgress * (3.0 - 2.0 * smoothedProgress); - - // Pure floating point interpolation - no dithering to eliminate flicker - const double blend = std::max(0.0, std::min(1.0, ultraSmoothProgress)); - - // High precision floating point color interpolation - const tsl::Color highlightColor = { - static_cast(dynamicLogoRGB1.r + (dynamicLogoRGB2.r - dynamicLogoRGB1.r) * blend + 0.5), - static_cast(dynamicLogoRGB1.g + (dynamicLogoRGB2.g - dynamicLogoRGB1.g) * blend + 0.5), - static_cast(dynamicLogoRGB1.b + (dynamicLogoRGB2.b - dynamicLogoRGB1.b) * blend + 0.5), - 15 - }; - - const std::string letterStr(1, letter); - x += renderer->drawString(letterStr, false, x, y + offset, fontSize, highlightColor).first; - countOffset -= static_cast(cycleDuration / 8.0); - } + + if (renderUseDynamicLogo) { + x = drawDynamicUltraText(renderer, x, y + offset, fontSize, logoColor1, false); } else { for (const char letter : ult::SPLIT_PROJECT_NAME_1) { const std::string letterStr(1, letter); x += renderer->drawString(letterStr, false, x, y + offset, fontSize, logoColor1).first; } } - + renderer->drawString(ult::SPLIT_PROJECT_NAME_2, false, x, y + offset, fontSize, (logoColor2)); } else { - if (m_showWidget) - renderer->drawWidget(); - + if (useCachedTop) { + if (g_cachedTop.widgetDrawn) { + renderer->drawWidget(); + } + } else { + if (m_showWidget) { + renderer->drawWidget(); + } + } + x = 20; - y = 52 -2; + y = 52 - 2; fontSize = 32; - if (m_subtitle.find("Ultrahand Script") != std::string::npos) { - renderer->drawString(m_title, false, x, y, fontSize, (defaultScriptColor)); + if (renderSubtitle.find("Ultrahand Script") != std::string::npos) { + renderer->drawString(renderTitle, false, x, y, fontSize, (defaultScriptColor)); } else { - titleColor = defaultPackageColor; // Default to green + tsl::Color drawColor = defaultPackageColor; // Default to green - // Ultra-fast color selection using first character optimization - if (!m_colorSelection.empty()) { - const char firstChar = m_colorSelection[0]; - const size_t len = m_colorSelection.length(); - - // Fast path: check first char + length for unique combinations - switch (firstChar) { - case 'g': // green - if (len == 5 && m_colorSelection == "green") { - titleColor = {0x0, 0xF, 0x0, 0xF}; - } - break; - case 'r': // red - if (len == 3 && m_colorSelection == "red") { - titleColor = RGB888("#F7253E"); - } - break; - case 'b': // blue - if (len == 4 && m_colorSelection == "blue") { - titleColor = {0x7, 0x7, 0xF, 0xF}; - } - break; - case 'y': // yellow - if (len == 6 && m_colorSelection == "yellow") { - titleColor = {0xF, 0xF, 0x0, 0xF}; - } - break; - case 'o': // orange - if (len == 6 && m_colorSelection == "orange") { - titleColor = {0xFF, 0xA5, 0x00, 0xFF}; - } - break; - case 'p': // pink or purple - if (len == 4 && m_colorSelection == "pink") { - titleColor = {0xFF, 0x69, 0xB4, 0xFF}; - } else if (len == 6 && m_colorSelection == "purple") { - titleColor = {0x80, 0x00, 0x80, 0xFF}; - } - break; - case 'w': // white - if (len == 5 && m_colorSelection == "white") { - titleColor = {0xF, 0xF, 0xF, 0xF}; - } - break; - case 'u': // ultra - if (len == 5 && m_colorSelection == "ultra") { - for (const char letter : m_title) { - progress = ult::calculateAmplitude(counter - x * 0.0001F); - - const tsl::Color highlightColor = { - static_cast((0xA - 0xF) * (3 - 1.5 * progress) + 0xF), - static_cast((0xA - 0xF) * 1.5 * progress + 0xF), - static_cast((0xA - 0xF) * (1.25 - progress) + 0xF), - 0xF - }; - - const std::string letterStr(1, letter); - renderer->drawString(letterStr.c_str(), false, x, y, fontSize, (highlightColor)); - const auto letterWidth = renderer->getTextDimensions(letterStr, false, fontSize).first; - x += letterWidth; - counter -= 0.00004F; + if (!useCachedTop) { + // Calculate color only if not using cache + if (!m_colorSelection.empty()) { + const char firstChar = m_colorSelection[0]; + const size_t len = m_colorSelection.length(); + + // Fast path: check first char + length for unique combinations + switch (firstChar) { + case 'g': // green + if (len == 5 && m_colorSelection.compare("green") == 0) { + drawColor = {0x0, 0xF, 0x0, 0xF}; } - goto skip_normal_draw; - } - break; - case '#': // hex color - if (len == 7 && ult::isValidHexColor(m_colorSelection.substr(1))) { - titleColor = RGB888(m_colorSelection.substr(1)); - } - break; + break; + case 'r': // red + if (len == 3 && m_colorSelection.compare("red") == 0) { + drawColor = RGB888("#F7253E"); + } + break; + case 'b': // blue + if (len == 4 && m_colorSelection.compare("blue") == 0) { + drawColor = {0x7, 0x7, 0xF, 0xF}; + } + break; + case 'y': // yellow + if (len == 6 && m_colorSelection.compare("yellow") == 0) { + drawColor = {0xF, 0xF, 0x0, 0xF}; + } + break; + case 'o': // orange + if (len == 6 && m_colorSelection.compare("orange") == 0) { + drawColor = {0xFF, 0xA5, 0x00, 0xFF}; + } + break; + case 'p': // pink or purple + if (len == 4 && m_colorSelection.compare("pink") == 0) { + drawColor = {0xFF, 0x69, 0xB4, 0xFF}; + } else if (len == 6 && m_colorSelection.compare("purple") == 0) { + drawColor = {0x80, 0x00, 0x80, 0xFF}; + } + break; + case 'w': // white + if (len == 5 && m_colorSelection.compare("white") == 0) { + drawColor = {0xF, 0xF, 0xF, 0xF}; + } + break; + case '#': // hex color + if (len == 7 && ult::isValidHexColor(m_colorSelection.substr(1))) { + drawColor = RGB888(m_colorSelection.substr(1)); + } + break; + } } + titleColor = drawColor; + } else { + drawColor = renderTitleColor; } - renderer->drawString(m_title, false, x, y, fontSize, (titleColor)); + renderer->drawString(renderTitle, false, x, y, fontSize, (drawColor)); y += 2; - skip_normal_draw:; } } + static const std::vector specialChars2 = {""}; - if (m_title == ult::CAPITAL_ULTRAHAND_PROJECT_NAME) { + if (renderTitle == ult::CAPITAL_ULTRAHAND_PROJECT_NAME) { renderer->drawStringWithColoredSections(ult::versionLabel, false, specialChars2, 20, y+25, 15, (bannerVersionTextColor), textSeparatorColor); } else { - std::string subtitle = m_subtitle; + std::string subtitle = renderSubtitle; const size_t pos = subtitle.find("?Ultrahand Script"); if (pos != std::string::npos) { subtitle.erase(pos, 17); // "?Ultrahand Script".length() = 17 } renderer->drawStringWithColoredSections(subtitle, false, specialChars2, 20, y+23, 15, (bannerVersionTextColor), textSeparatorColor); } + + // Update top cache after rendering for next frame + g_cachedTop.title = m_title; + g_cachedTop.subtitle = m_subtitle; + g_cachedTop.titleColor = titleColor; + g_cachedTop.useDynamicLogo = ult::useDynamicLogo; + // Store whether widget was ACTUALLY drawn this frame + if (isUltrahandMenu) { + g_cachedTop.widgetDrawn = true; // Ultrahand menu always shows widget + } else { + g_cachedTop.widgetDrawn = m_showWidget; // Other menus use m_showWidget + } + g_cachedTop.disabled = false; #else + // NON-LAUNCHER PATH WITH CACHE SUPPORT if (m_noClickableItems != ult::noClickableItems.load(std::memory_order_acquire)) { ult::noClickableItems.store(m_noClickableItems, std::memory_order_release); } - #if USING_WIDGET_DIRECTIVE - if (m_showWidget) - renderer->drawWidget(); - #endif - renderer->drawString(m_title, false, 20, 52-2, 32, (defaultOverlayColor)); - renderer->drawString(m_subtitle, false, 20, y+2+23+2, 15, (bannerVersionTextColor)); + // Determine if we should use cached data (first frame of new overlay) + const bool useCachedTop = !g_cachedTop.disabled && + !g_cachedTop.title.empty() && + (g_cachedTop.title != m_title || g_cachedTop.subtitle != m_subtitle); + + // Use cached or current data for rendering + const std::string& renderTitle = useCachedTop ? g_cachedTop.title : m_title; + const std::string& renderSubtitle = useCachedTop ? g_cachedTop.subtitle : m_subtitle; + + #if USING_WIDGET_DIRECTIVE + if (useCachedTop) { + if (g_cachedTop.widgetDrawn) { + renderer->drawWidget(); + } + } else { + if (m_showWidget) + renderer->drawWidget(); + } + #endif + + renderer->drawString(renderTitle, false, 20, 52-2, 32, (defaultOverlayColor)); + renderer->drawString(renderSubtitle, false, 20, y+2+23+2, 15, (bannerVersionTextColor)); + + // Update top cache after rendering for next frame + g_cachedTop.title = m_title; + g_cachedTop.subtitle = m_subtitle; + g_cachedTop.titleColor = {0xF, 0xF, 0xF, 0xF}; + #if USING_WIDGET_DIRECTIVE + g_cachedTop.widgetDrawn = m_showWidget; + #else + g_cachedTop.widgetDrawn = false; + #endif + g_cachedTop.useDynamicLogo = false; + g_cachedTop.disabled = false; #endif renderer->drawRect(15, tsl::cfg::FramebufferHeight - 73, tsl::cfg::FramebufferWidth - 30, 1, a(bottomSeparatorColor)); - + // Compute gap width once from GAP_1 and derive halfGap const float gapWidth = renderer->getTextDimensions(ult::GAP_1, false, 23).first; // Calculate text widths for buttons depending on launch mode and interpreter state - #if IS_LAUNCHER_DIRECTIVE - const float backTextWidth = renderer->getTextDimensions( - "\uE0E1" + ult::GAP_2 + (!interpreterIsRunningNow ? ult::BACK : ult::HIDE), false, 23).first; - const float selectTextWidth = renderer->getTextDimensions( - "\uE0E0" + ult::GAP_2 + (!interpreterIsRunningNow ? ult::OK : ult::CANCEL), false, 23).first; - #else - const float backTextWidth = renderer->getTextDimensions( - "\uE0E1" + ult::GAP_2 + ult::BACK, false, 23).first; - const float selectTextWidth = renderer->getTextDimensions( - "\uE0E0" + ult::GAP_2 + ult::OK, false, 23).first; - #endif + #if IS_LAUNCHER_DIRECTIVE + const float backTextWidth = renderer->getTextDimensions( + "\uE0E1" + ult::GAP_2 + (!interpreterIsRunningNow ? ult::BACK : ult::HIDE), false, 23).first; + const float selectTextWidth = renderer->getTextDimensions( + "\uE0E0" + ult::GAP_2 + (!interpreterIsRunningNow ? ult::OK : ult::CANCEL), false, 23).first; + #else + const float backTextWidth = renderer->getTextDimensions( + "\uE0E1" + ult::GAP_2 + ult::BACK, false, 23).first; + const float selectTextWidth = renderer->getTextDimensions( + "\uE0E0" + ult::GAP_2 + ult::OK, false, 23).first; + #endif const float _halfGap = gapWidth / 2.0f; if (_halfGap != ult::halfGap.load(std::memory_order_acquire)) ult::halfGap.store(_halfGap, std::memory_order_release); - + // Total button widths include half-gap padding on both sides const float _backWidth = backTextWidth + gapWidth; if (_backWidth != ult::backWidth.load(std::memory_order_acquire)) @@ -5038,7 +4980,7 @@ namespace tsl { _selectWidth-2, 73.0f, 10.0f, a(clickColor)); } - #if IS_LAUNCHER_DIRECTIVE + #if IS_LAUNCHER_DIRECTIVE // Handle optional next page button when in launcher mode and appropriate conditions are met if (!interpreterIsRunningNow && (ult::inMainMenu.load(std::memory_order_acquire) || !m_pageLeftName.empty() || !m_pageRightName.empty())) { @@ -5047,14 +4989,14 @@ namespace tsl { !m_pageLeftName.empty() ? ("\uE0ED" + ult::GAP_2 + m_pageLeftName) : !m_pageRightName.empty() ? ("\uE0EE" + ult::GAP_2 + m_pageRightName) : (ult::inMainMenu.load(std::memory_order_acquire) ? - ((m_menuMode == "packages" ? + (((m_menuMode.compare("packages") == 0) ? (ult::usePageSwap ? "\uE0EE" : "\uE0ED") : (ult::usePageSwap ? "\uE0ED" : "\uE0EE")) + ult::GAP_2 + (ult::inOverlaysPage.load(std::memory_order_acquire) ? ult::PACKAGES : ult::OVERLAYS_ABBR)) : ""), false, 23).first + gapWidth; - + if (_nextPageWidth != ult::nextPageWidth.load(std::memory_order_acquire)) ult::nextPageWidth.store(_nextPageWidth, std::memory_order_release); @@ -5069,12 +5011,10 @@ namespace tsl { 73.0f, 10.0f, a(clickColor)); } } - #endif + #endif - - #if IS_LAUNCHER_DIRECTIVE - - const std::string menuBottomLine = + #if IS_LAUNCHER_DIRECTIVE + std::string currentBottomLine = "\uE0E1" + ult::GAP_2 + (interpreterIsRunningNow ? ult::HIDE : ult::BACK) + ult::GAP_1 + (!m_noClickableItems && !interpreterIsRunningNow @@ -5085,14 +5025,14 @@ namespace tsl { : "") + (!interpreterIsRunningNow ? (!ult::usePageSwap - ? (m_menuMode == "packages" + ? ((m_menuMode.compare("packages") == 0) ? "\uE0ED" + ult::GAP_2 + ult::OVERLAYS_ABBR - : m_menuMode == "overlays" + : (m_menuMode.compare("overlays") == 0) ? "\uE0EE" + ult::GAP_2 + ult::PACKAGES : "") - : (m_menuMode == "packages" + : ((m_menuMode.compare("packages") == 0) ? "\uE0EE" + ult::GAP_2 + ult::OVERLAYS_ABBR - : m_menuMode == "overlays" + : (m_menuMode.compare("overlays") == 0) ? "\uE0ED" + ult::GAP_2 + ult::PACKAGES : "")) : "") + @@ -5101,20 +5041,38 @@ namespace tsl { : !interpreterIsRunningNow && !m_pageRightName.empty() ? "\uE0EE" + ult::GAP_2 + m_pageRightName : ""); - #else - const std::string menuBottomLine = + #else + std::string currentBottomLine = "\uE0E1" + ult::GAP_2 + ult::BACK + ult::GAP_1 + (!m_noClickableItems ? "\uE0E0" + ult::GAP_2 + ult::OK + ult::GAP_1 : ""); - #endif + #endif + + // Determine if we should use cached bottom text (first frame of new overlay) + const bool useCachedBottom = !g_cachedBottom.disabled && + !g_cachedBottom.bottomText.empty() && + g_cachedBottom.bottomText != currentBottomLine; + + const std::string& menuBottomLine = useCachedBottom ? g_cachedBottom.bottomText : currentBottomLine; // Render the text - it starts halfGap inside the first button, so edgePadding + halfGap static const std::vector specialChars = {"\uE0E1","\uE0E0","\uE0ED","\uE0EE","\uE0E5"}; renderer->drawStringWithColoredSections(menuBottomLine, false, specialChars, buttonStartX, 693, 23, (bottomTextColor), (buttonColor)); - + + // Update bottom cache after rendering for next frame + g_cachedBottom.bottomText = currentBottomLine; + g_cachedBottom.backWidth = _backWidth; + g_cachedBottom.selectWidth = _selectWidth; + #if IS_LAUNCHER_DIRECTIVE + g_cachedBottom.nextPageWidth = ult::nextPageWidth.load(std::memory_order_acquire); + #else + g_cachedBottom.nextPageWidth = 0.0f; + #endif + g_cachedBottom.disabled = false; + #if USING_FPS_INDICATOR_DIRECTIVE // Update and display FPS const u64 currentTime_ns = armTicksToNs(armGetSystemTick()); @@ -5135,11 +5093,12 @@ namespace tsl { if (m_contentElement != nullptr) m_contentElement->frame(renderer); - + if (!ult::useRightAlignment) renderer->drawRect(447, 0, 448, 720, a(edgeSeparatorColor)); else renderer->drawRect(0, 0, 1, 720, a(edgeSeparatorColor)); + } // CUSTOM SECTION END @@ -5230,7 +5189,7 @@ namespace tsl { if (FullMode) ult::loadWallpaperFileWhenSafe(); else - svcSleepThread(180'000); // sleep thread for initial values to auto-load + svcSleepThread(250'000); // sleep thread for initial values to auto-load m_isItem = false; } @@ -5238,6 +5197,12 @@ namespace tsl { virtual ~HeaderOverlayFrame() { if (this->m_contentElement != nullptr) delete this->m_contentElement; + + // Check if returning from a list that disabled caching + if (g_disableMenuCacheOnReturn.exchange(false, std::memory_order_acq_rel)) { + g_cachedTop.disabled = true; + g_cachedBottom.disabled = true; + } } @@ -5254,7 +5219,8 @@ namespace tsl { if (FullMode == true) { renderer->fillScreen(a(defaultBackgroundColor)); - renderer->drawWallpaper(); + if (lastMode.empty() || (lastMode.compare("returning") == 0)) + renderer->drawWallpaper(); } else { renderer->fillScreen({ 0x0, 0x0, 0x0, 0x0}); } @@ -5262,8 +5228,17 @@ namespace tsl { y = 50; offset = 0; - renderer->drawString(this->m_title, false, 20, 50, 32, (defaultOverlayColor)); - renderer->drawString(this->m_subtitle, false, 20, y+2+23+2, 15, (bannerVersionTextColor)); + // Determine if we should use cached data (first frame of new overlay) + const bool useCachedTop = !g_cachedTop.disabled && + !g_cachedTop.title.empty() && + (g_cachedTop.title != m_title || g_cachedTop.subtitle != m_subtitle); + + // Use cached or current data for rendering + const std::string& renderTitle = useCachedTop ? g_cachedTop.title : m_title; + const std::string& renderSubtitle = useCachedTop ? g_cachedTop.subtitle : m_subtitle; + + renderer->drawString(renderTitle, false, 20, 50, 32, (defaultOverlayColor)); + renderer->drawString(renderSubtitle, false, 20, y+2+23+2, 15, (bannerVersionTextColor)); if (FullMode == true) renderer->drawRect(15, tsl::cfg::FramebufferHeight - 73, tsl::cfg::FramebufferWidth - 30, 1, a(bottomSeparatorColor)); @@ -5273,24 +5248,24 @@ namespace tsl { if (FullMode && !deactivateOriginalFooter) { // Get the exact gap width from ult::GAP_1 - static const auto gapWidth = renderer->getTextDimensions(ult::GAP_1, false, 23).first; - static const float _halfGap = gapWidth / 2.0f; + const auto gapWidth = renderer->getTextDimensions(ult::GAP_1, false, 23).first; + const float _halfGap = gapWidth / 2.0f; if (_halfGap != ult::halfGap.load(std::memory_order_acquire)) ult::halfGap.store(_halfGap, std::memory_order_release); // Calculate text dimensions for buttons without gaps - static const auto backTextWidth = renderer->getTextDimensions("\uE0E1" + ult::GAP_2 + ult::BACK, false, 23).first; - static const auto selectTextWidth = renderer->getTextDimensions("\uE0E0" + ult::GAP_2 + ult::OK, false, 23).first; + const auto backTextWidth = renderer->getTextDimensions("\uE0E1" + ult::GAP_2 + ult::BACK, false, 23).first; + const auto selectTextWidth = renderer->getTextDimensions("\uE0E0" + ult::GAP_2 + ult::OK, false, 23).first; // Update widths to include the half-gap padding on each side - static const float _backWidth = backTextWidth + gapWidth; + const float _backWidth = backTextWidth + gapWidth; if (_backWidth != ult::backWidth.load(std::memory_order_acquire)) ult::backWidth.store(_backWidth, std::memory_order_release); - static const float _selectWidth = selectTextWidth + gapWidth; + const float _selectWidth = selectTextWidth + gapWidth; if (_selectWidth != ult::selectWidth.load(std::memory_order_acquire)) ult::selectWidth.store(_selectWidth, std::memory_order_release); - static const float buttonY = static_cast(cfg::FramebufferHeight - 73 + 1); + const float buttonY = static_cast(cfg::FramebufferHeight - 73 + 1); // Draw back button rectangle if (ult::touchingBack.load(std::memory_order_acquire)) { @@ -5304,18 +5279,26 @@ namespace tsl { } } + // Build current bottom line + const std::string currentBottomLine = + "\uE0E1" + ult::GAP_2 + ult::BACK + ult::GAP_1 + + (!m_noClickableItems + ? "\uE0E0" + ult::GAP_2 + ult::OK + ult::GAP_1 + : ""); + + // Determine if we should use cached bottom text (first frame of new overlay) + const bool useCachedBottom = !g_cachedBottom.disabled && + !g_cachedBottom.bottomText.empty() && + g_cachedBottom.bottomText != currentBottomLine; + + const std::string& menuBottomLine = useCachedBottom ? g_cachedBottom.bottomText : currentBottomLine; + // Render the text with special character handling if (!deactivateOriginalFooter) { - const std::string menuBottomLine = - "\uE0E1" + ult::GAP_2 + ult::BACK + ult::GAP_1 + - (!m_noClickableItems - ? "\uE0E0" + ult::GAP_2 + ult::OK + ult::GAP_1 - : ""); static const std::vector specialChars = {"\uE0E1","\uE0E0","\uE0ED","\uE0EE","\uE0E5"}; renderer->drawStringWithColoredSections(menuBottomLine, false, specialChars, buttonStartX, 693, 23, (bottomTextColor), (buttonColor)); } - if (this->m_contentElement != nullptr) this->m_contentElement->frame(renderer); @@ -5325,6 +5308,21 @@ namespace tsl { else renderer->drawRect(0, 0, 1, 720, a(edgeSeparatorColor)); } + + // Update top cache after rendering for next frame + g_cachedTop.title = m_title; + g_cachedTop.subtitle = m_subtitle; + g_cachedTop.titleColor = {0xF, 0xF, 0xF, 0xF}; // HeaderOverlayFrame uses default white + g_cachedTop.widgetDrawn = false; // HeaderOverlayFrame doesn't use widgets + g_cachedTop.useDynamicLogo = false; // HeaderOverlayFrame doesn't use dynamic logo + g_cachedTop.disabled = false; + + // Update bottom cache after rendering for next frame + g_cachedBottom.bottomText = currentBottomLine; + g_cachedBottom.backWidth = ult::backWidth.load(std::memory_order_acquire); + g_cachedBottom.selectWidth = ult::selectWidth.load(std::memory_order_acquire); + g_cachedBottom.nextPageWidth = 0.0f; // HeaderOverlayFrame doesn't use next page + g_cachedBottom.disabled = false; } @@ -5422,8 +5420,7 @@ namespace tsl { } virtual void draw(gfx::Renderer *renderer) override { - if (!ult::themeIsInitialized.load(std::memory_order_acquire)) { - ult::themeIsInitialized.store(true, std::memory_order_release); + if (!ult::themeIsInitialized.exchange(true, std::memory_order_acq_rel)) { tsl::initializeThemeVars(); } @@ -5938,22 +5935,17 @@ namespace tsl { return handleJumpToItem(oldFocus); // needs to be handled 2x for proper rendering } - if (jumpToBottom.load(std::memory_order_acquire)) { - jumpToBottom.store(false, std::memory_order_release); + if (jumpToBottom.exchange(false, std::memory_order_acq_rel)) return handleJumpToBottom(oldFocus); - } - if (jumpToTop.load(std::memory_order_acquire)) { - jumpToTop.store(false, std::memory_order_release); + + if (jumpToTop.exchange(false, std::memory_order_acq_rel)) return handleJumpToTop(oldFocus); - } - if (skipDown.load(std::memory_order_acquire)) { - skipDown.store(false, std::memory_order_release); + + if (skipDown.exchange(false, std::memory_order_acq_rel)) return handleSkipDown(oldFocus); - } - if (skipUp.load(std::memory_order_acquire)) { - skipUp.store(false, std::memory_order_release); + + if (skipUp.exchange(false, std::memory_order_acq_rel)) return handleSkipUp(oldFocus); - } if (direction == FocusDirection::None) { @@ -5970,11 +5962,7 @@ namespace tsl { } inline void jumpToItem(const std::string& text = "", const std::string& value = "", bool exactMatch=true) { - //if (!text.empty() || !value.empty()) - // m_pendingJump = true; - //else - // m_pendingJump = false; - //if (g_overlayFilename == "ovlmenu.ovl") return; + if (!text.empty() || !value.empty()) { m_pendingJump = true; m_jumpToText = text; @@ -6015,6 +6003,8 @@ namespace tsl { inline void disableCaching() { m_cachingDisabled = true; + //clearFrameCache(); + g_disableMenuCacheOnReturn.store(true, std::memory_order_release); } protected: @@ -6084,23 +6074,6 @@ namespace tsl { NavigationResult m_lastNavigationResult = NavigationResult::None; private: - // Method to explicitly preserve cache when navigating away - //void preserveCacheForReturn() { - // if (m_instanceId == s_cachedInstanceId && s_hasValidFrame) { - // // Cache is already preserved for this instance - // return; - // } - // cacheCurrentFrame(); - //} - - // Method to check if this instance has a valid cached frame - //bool hasCachedFrame() const { - // return s_hasValidFrame && s_cachedInstanceId == m_instanceId; - //} - - //static size_t generateInstanceId() { - // return s_nextInstanceId++; - //} // Thread-safe versions (handle their own locking) static void clearStaticCache(bool preservePointers = false) { @@ -6223,11 +6196,6 @@ namespace tsl { void clearItems() { - //std::lock_guard lock(s_lastFrameItemsMutex); - // Clear static cache if it belongs to this instance - //if (s_cachedInstanceId == m_instanceId) { - // clearStaticCache(); - //} for (Element* item : m_items) delete item; m_items = {}; @@ -6383,11 +6351,7 @@ namespace tsl { const float viewBottom = m_offset + getHeight(); if (itemTop < m_offset || itemBottom > viewBottom) { - float emergencySpeed = 0.6f; - - if (itemBottom < m_offset || itemTop > viewBottom) { - emergencySpeed = 0.9f; - } + const float emergencySpeed = (itemBottom < m_offset || itemTop > viewBottom) ? 0.9f : 0.6f; m_offset += diff * emergencySpeed; m_scrollVelocity = diff * 0.3f; @@ -6450,10 +6414,10 @@ namespace tsl { const float viewCenter = m_offset + (getHeight() / 2.0f); float accumHeight = 0.0f; - float itemHeight, itemCenter; + //float itemHeight, itemCenter; for (size_t i = 0; i < m_items.size(); ++i) { - itemHeight = m_items[i]->getHeight(); - itemCenter = accumHeight + (itemHeight / 2.0f); + const float itemHeight = m_items[i]->getHeight(); + const float itemCenter = accumHeight + (itemHeight / 2.0f); if (itemCenter >= viewCenter) { m_focusedIndex = i; @@ -6514,18 +6478,19 @@ namespace tsl { inline Element* handleDownFocus(Element* oldFocus) { static bool triggerShakeOnce = true; + const bool atBottom = isAtBottom(); updateHoldState(); // Check if the next item is non-focusable BEFORE we do anything else if (m_focusedIndex + 1 < int(m_items.size())) { Element* nextItem = m_items[m_focusedIndex + 1]; if (!nextItem->m_isItem) { - isTableScrolling.store(true, std::memory_order_release); // Set this IMMEDIATELY + isTableScrolling.store(true, std::memory_order_release); } } // If holding and at boundary, try to scroll first - if (m_isHolding && m_stoppedAtBoundary && !isAtBottom()) { + if (m_isHolding && m_stoppedAtBoundary && !atBottom) { scrollDown(); m_stoppedAtBoundary = false; return oldFocus; @@ -6536,68 +6501,77 @@ namespace tsl { if (result != oldFocus) { m_lastNavigationResult = NavigationResult::Success; m_stoppedAtBoundary = false; - triggerShakeOnce = true; + triggerShakeOnce = true; // This resets it for THIS function + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + triggerNavigationFeedback(); return result; } // Check if we can still scroll down - if (!isAtBottom()) { + if (!atBottom) { scrollDown(); + triggerShakeOnce = true; // ADDED: Reset when scrolling away from boundary return oldFocus; } - // At absolute bottom - check for wrapping - if (!m_isHolding && !m_hasWrappedInCurrentSequence && isAtBottom()) { - //if (s_directionalKeyReleased.load(std::memory_order_acquire)) { - // s_directionalKeyReleased.store(false, std::memory_order_release); - // m_hasWrappedInCurrentSequence = true; - // m_lastNavigationResult = NavigationResult::Wrapped; - // triggerShakeOnce = true; // Reset when wrapping - // return handleJumpToTop(oldFocus); - //} else - // s_directionalKeyReleased.store(false, std::memory_order_release); - + // At absolute bottom - check for wrapping (single tap) + if (!m_isHolding && !m_hasWrappedInCurrentSequence && atBottom) { s_directionalKeyReleased.store(false, std::memory_order_release); m_hasWrappedInCurrentSequence = true; m_lastNavigationResult = NavigationResult::Wrapped; + + //if (result->m_isItem) { triggerShakeOnce = true; // Reset when wrapping + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + //} return handleJumpToTop(oldFocus); } - // Set boundary flag - if (m_isHolding) { + // Set boundary flag (for holding) + if (m_isHolding && atBottom) { m_stoppedAtBoundary = true; if (triggerShakeOnce) { - // Find the last focusable item to shake - for (ssize_t i = static_cast(m_focusedIndex); i >= 0; --i) { - if (m_items[i]->m_isItem) { - m_items[i]->shakeHighlight(FocusDirection::Down); - break; + if (result->m_isItem) { + triggerRumbleClick.store(true, std::memory_order_release); + triggerWallSound.store(true, std::memory_order_release); + + for (ssize_t i = static_cast(m_focusedIndex); i >= 0; --i) { + if (m_items[i]->m_isItem) { + m_items[i]->shakeHighlight(FocusDirection::Down); + break; + } } + } else { + triggerRumbleClick.store(true, std::memory_order_release); + triggerWallSound.store(true, std::memory_order_release); } triggerShakeOnce = false; } - } else + } else if (!m_isHolding) { triggerShakeOnce = true; - + } + m_lastNavigationResult = NavigationResult::HitBoundary; return oldFocus; } inline Element* handleUpFocus(Element* oldFocus) { static bool triggerShakeOnce = true; + const bool atTop = isAtTop(); updateHoldState(); // Check if the previous item is non-focusable BEFORE we do anything else if (m_focusedIndex > 0) { Element* prevItem = m_items[m_focusedIndex - 1]; if (prevItem->isTable()) { - isTableScrolling.store(true, std::memory_order_release); // Set this IMMEDIATELY + isTableScrolling.store(true, std::memory_order_release); } } // If holding and at boundary, try to scroll first - if (m_isHolding && m_stoppedAtBoundary && !isAtTop()) { + if (m_isHolding && m_stoppedAtBoundary && !atTop) { scrollUp(); m_stoppedAtBoundary = false; return oldFocus; @@ -6608,54 +6582,62 @@ namespace tsl { if (result != oldFocus) { m_lastNavigationResult = NavigationResult::Success; m_stoppedAtBoundary = false; - triggerShakeOnce = true; + triggerShakeOnce = true; // This resets it for THIS function + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + triggerNavigationFeedback(); return result; } // Check if we can still scroll up - if (!isAtTop()) { + if (!atTop) { scrollUp(); + triggerShakeOnce = true; // ADDED: Reset when scrolling away from boundary return oldFocus; } - // At absolute top - check for wrapping - if (!m_isHolding && !m_hasWrappedInCurrentSequence && isAtTop()) { - //if (s_directionalKeyReleased.load(std::memory_order_acquire)) { - // s_directionalKeyReleased.store(false, std::memory_order_release); - // m_hasWrappedInCurrentSequence = true; - // m_lastNavigationResult = NavigationResult::Wrapped; - // triggerShakeOnce = true; // Reset when wrapping - // return handleJumpToBottom(oldFocus); - //} else - // s_directionalKeyReleased.store(false, std::memory_order_release); - + // At absolute top - check for wrapping (single tap) + if (!m_isHolding && !m_hasWrappedInCurrentSequence && atTop) { s_directionalKeyReleased.store(false, std::memory_order_release); m_hasWrappedInCurrentSequence = true; m_lastNavigationResult = NavigationResult::Wrapped; + + //if (result->m_isItem) { triggerShakeOnce = true; // Reset when wrapping + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + //} return handleJumpToBottom(oldFocus); } - // Set boundary flag - if (m_isHolding) { + // Set boundary flag (for holding) + if (m_isHolding && atTop) { m_stoppedAtBoundary = true; if (triggerShakeOnce) { - // Find the first focusable item to shake - for (size_t i = m_focusedIndex; i < m_items.size(); ++i) { - if (m_items[i]->m_isItem) { - m_items[i]->shakeHighlight(FocusDirection::Up); - break; + if (result->m_isItem) { + triggerRumbleClick.store(true, std::memory_order_release); + triggerWallSound.store(true, std::memory_order_release); + + for (size_t i = m_focusedIndex; i < m_items.size(); ++i) { + if (m_items[i]->m_isItem) { + m_items[i]->shakeHighlight(FocusDirection::Up); + break; + } } + } else { + triggerRumbleClick.store(true, std::memory_order_release); + triggerWallSound.store(true, std::memory_order_release); } triggerShakeOnce = false; } - } else + } else if (!m_isHolding) { triggerShakeOnce = true; - + } + m_lastNavigationResult = NavigationResult::HitBoundary; return oldFocus; } - + inline bool isAtTop() { if (m_items.empty()) return true; @@ -6958,20 +6940,19 @@ namespace tsl { m_nextOffset = std::max(m_nextOffset - scrollAmount, 0.0f); } - // Add these methods to handle jumps with smooth scrolling + // Jump to Bottom (original behavior + fixed trigger condition) Element* handleJumpToBottom(Element* oldFocus) { if (m_items.empty()) return oldFocus; invalidate(); resetNavigationState(); - jumpToBottom.store(false, std::memory_order_release); // Reset flag + jumpToBottom.store(false, std::memory_order_release); - // Calculate target offset once (good optimization to keep) - const float targetOffset = (m_listHeight > getHeight()) ? + const float targetOffset = (m_listHeight > getHeight()) ? static_cast(m_listHeight - getHeight()) : 0.0f; static constexpr float tolerance = 5.0f; - - // Find the last focusable item + + // Find last focusable item (search backward) size_t lastFocusableIndex = m_items.size(); for (ssize_t i = static_cast(m_items.size()) - 1; i >= 0; --i) { Element* test = m_items[i]->requestFocus(nullptr, FocusDirection::None); @@ -6980,47 +6961,46 @@ namespace tsl { break; } } - - // Check if we're already at the bottom with proper tolerance - bool alreadyAtBottom = false; - if (lastFocusableIndex < m_items.size()) { - alreadyAtBottom = (m_focusedIndex == lastFocusableIndex) && - (std::abs(m_nextOffset - targetOffset) <= tolerance); - } - - if (alreadyAtBottom) { - return oldFocus; // Already at bottom, do nothing - } - - // Not at bottom - perform the jump using SAME logic as wrapToBottom - if (lastFocusableIndex < m_items.size()) { - m_focusedIndex = lastFocusableIndex; - m_nextOffset = targetOffset; // Use same calculation as wrapToBottom - - Element* newFocus = m_items[lastFocusableIndex]->requestFocus(oldFocus, FocusDirection::None); - if (newFocus && newFocus != oldFocus) { - return newFocus; - } - } - - // No focusable items - just set target to bottom (same as wrapToBottom) + + if (lastFocusableIndex == m_items.size()) + return oldFocus; // no focusable items + + bool alreadyAtBottom = (m_focusedIndex == lastFocusableIndex) && + (std::abs(m_nextOffset - targetOffset) <= tolerance); + if (alreadyAtBottom) + return oldFocus; + + const float oldOffset = m_nextOffset; + m_focusedIndex = lastFocusableIndex; m_nextOffset = targetOffset; - return oldFocus; + + Element* newFocus = m_items[lastFocusableIndex]->requestFocus(oldFocus, FocusDirection::None); + + // Trigger feedback if offset or focus changed + if ((newFocus && newFocus != oldFocus) || + (std::abs(m_nextOffset - oldOffset) > tolerance)) { + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + triggerNavigationFeedback(); + } + + return newFocus ? newFocus : oldFocus; } + + // Jump to Top (original behavior + fixed trigger condition) Element* handleJumpToTop(Element* oldFocus) { if (m_items.empty()) return oldFocus; - + invalidate(); resetNavigationState(); - jumpToTop.store(false, std::memory_order_release); // Reset flag - - // Define constants for clarity and consistency + jumpToTop.store(false, std::memory_order_release); + static constexpr float targetOffset = 0.0f; - static constexpr float tolerance = 0.0f; - - // Find the first focusable item - size_t firstFocusableIndex = m_items.size(); // Default to invalid + static constexpr float tolerance = 5.0f; + + // Find first focusable item (search forward) + size_t firstFocusableIndex = m_items.size(); for (size_t i = 0; i < m_items.size(); ++i) { Element* test = m_items[i]->requestFocus(nullptr, FocusDirection::None); if (test) { @@ -7028,32 +7008,30 @@ namespace tsl { break; } } - - // Check if we're already at the top with proper tolerance - bool alreadyAtTop = false; - if (firstFocusableIndex < m_items.size()) { - alreadyAtTop = (m_focusedIndex == firstFocusableIndex) && - (std::abs(m_nextOffset - targetOffset) <= tolerance); - } - - if (alreadyAtTop) { - return oldFocus; // Already at top, do nothing - } - - // Not at top - perform the jump using SAME logic as wrapToTop - if (firstFocusableIndex < m_items.size()) { - m_focusedIndex = firstFocusableIndex; - m_nextOffset = targetOffset; // Same as wrapToTop - - Element* newFocus = m_items[firstFocusableIndex]->requestFocus(oldFocus, FocusDirection::None); - if (newFocus && newFocus != oldFocus) { - return newFocus; - } - } - - // No focusable items - just set target to top (same as wrapToTop) + + if (firstFocusableIndex == m_items.size()) + return oldFocus; // no focusable items + + bool alreadyAtTop = (m_focusedIndex == firstFocusableIndex) && + (std::abs(m_nextOffset - targetOffset) <= tolerance); + if (alreadyAtTop) + return oldFocus; + + const float oldOffset = m_nextOffset; + m_focusedIndex = firstFocusableIndex; m_nextOffset = targetOffset; - return oldFocus; + + Element* newFocus = m_items[firstFocusableIndex]->requestFocus(oldFocus, FocusDirection::None); + + // Trigger feedback if offset or focus changed + if ((newFocus && newFocus != oldFocus) || + (std::abs(m_nextOffset - oldOffset) > tolerance)) { + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + triggerNavigationFeedback(); + } + + return newFocus ? newFocus : oldFocus; } Element* handleSkipDown(Element* oldFocus) { @@ -7062,12 +7040,11 @@ namespace tsl { invalidate(); resetNavigationState(); - // Calculate target offset once (good optimization to keep) - const float targetOffset = (m_listHeight > getHeight()) ? + const float targetOffset = (m_listHeight > getHeight()) ? static_cast(m_listHeight - getHeight()) : 0.0f; static constexpr float tolerance = 0.0f; - - // Find the last focusable item + + // Find last focusable item size_t lastFocusableIndex = m_items.size(); for (ssize_t i = static_cast(m_items.size()) - 1; i >= 0; --i) { Element* test = m_items[i]->requestFocus(nullptr, FocusDirection::None); @@ -7076,31 +7053,21 @@ namespace tsl { break; } } - - // Check if we're already at the bottom with proper tolerance - bool alreadyAtBottom = false; - if (lastFocusableIndex < m_items.size()) { - alreadyAtBottom = (m_focusedIndex == lastFocusableIndex) && - (std::abs(m_nextOffset - targetOffset) <= tolerance); - } - - if (alreadyAtBottom) { - return oldFocus; // Already at bottom, do nothing - } - - - const float viewHeight = static_cast(getHeight()); - const float maxOffset = (m_listHeight > getHeight()) ? static_cast(m_listHeight - getHeight()) : 0.0f; - // Calculate the target viewport center after skipping + const bool alreadyAtBottom = (lastFocusableIndex < m_items.size()) && + (m_focusedIndex == lastFocusableIndex) && + (std::abs(m_nextOffset - targetOffset) <= tolerance); + + if (alreadyAtBottom) return oldFocus; + + const float viewHeight = static_cast(getHeight()); + const float maxOffset = (m_listHeight > viewHeight) ? static_cast(m_listHeight - viewHeight) : 0.0f; const float targetViewportTop = std::min(m_offset + viewHeight, maxOffset); - - // Check if we traveled less than a full viewport + const float actualTravelDistance = targetViewportTop - m_offset; const bool traveledFullViewport = (actualTravelDistance >= viewHeight - tolerance); const float targetViewportCenter = targetViewportTop + (viewHeight / 2.0f + VIEW_CENTER_OFFSET); - // Find the item closest to the center of the new viewport float itemTop = 0.0f; size_t targetIndex = 0; bool foundFocusable = false; @@ -7111,7 +7078,6 @@ namespace tsl { const float itemCenter = itemTop + (itemHeight / 2.0f); const float distanceFromCenter = std::abs(itemCenter - targetViewportCenter); - // Check if this item is focusable and closer to center Element* test = m_items[i]->requestFocus(nullptr, FocusDirection::None); if (test && test->m_isItem && distanceFromCenter < bestDistance) { targetIndex = i; @@ -7122,6 +7088,8 @@ namespace tsl { itemTop += itemHeight; } + const float oldOffset = m_nextOffset; + if (foundFocusable) { bool nearBottom = true; if (targetIndex > m_focusedIndex && traveledFullViewport) { @@ -7129,46 +7097,59 @@ namespace tsl { nearBottom = false; } isTableScrolling.store(false, std::memory_order_release); - updateScrollOffset(); // This will center the cursor properly - + updateScrollOffset(); + Element* newFocus = m_items[targetIndex]->requestFocus(oldFocus, FocusDirection::None); - return (newFocus && newFocus != oldFocus && !nearBottom && traveledFullViewport) ? newFocus : handleJumpToBottom(oldFocus); + + if (newFocus && newFocus != oldFocus && !nearBottom && traveledFullViewport) { + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + triggerNavigationFeedback(); + return newFocus; + } else { + return handleJumpToBottom(oldFocus); + } } else { + // Scroll viewport even if no focusable items isTableScrolling.store(true, std::memory_order_release); m_nextOffset = targetViewportTop; - - // NEW: Find the last focusable item that's still visible + + if (std::abs(m_nextOffset - oldOffset) > 0.0f) { + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + triggerNavigationFeedback(); + } + + // Focus last visible focusable item float searchItemTop = 0.0f; - size_t lastVisibleFocusable = m_focusedIndex; // Default to current - + size_t lastVisibleFocusable = m_focusedIndex; + for (size_t i = 0; i < m_items.size(); ++i) { const float itemHeight = m_items[i]->getHeight(); const float itemBottom = searchItemTop + itemHeight; - - // Stop if we've gone past the new viewport + if (searchItemTop >= targetViewportTop + viewHeight) break; - - // Check if this item is focusable and visible in the new viewport + if (itemBottom > targetViewportTop) { Element* test = m_items[i]->requestFocus(nullptr, FocusDirection::None); - if (test && test->m_isItem) { - lastVisibleFocusable = i; - } + if (test && test->m_isItem) lastVisibleFocusable = i; } - + searchItemTop += itemHeight; } - - // Focus on the last visible focusable item + if (lastVisibleFocusable != m_focusedIndex) { m_focusedIndex = lastVisibleFocusable; Element* newFocus = m_items[m_focusedIndex]->requestFocus(oldFocus, FocusDirection::None); if (newFocus && newFocus != oldFocus) { + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + triggerNavigationFeedback(); return newFocus; } } } - + return oldFocus; } @@ -7178,12 +7159,11 @@ namespace tsl { invalidate(); resetNavigationState(); - // Define constants for clarity and consistency static constexpr float targetOffset = 0.0f; static constexpr float tolerance = 0.0f; - - // Find the first focusable item - size_t firstFocusableIndex = m_items.size(); // Default to invalid + + // Find first focusable item + size_t firstFocusableIndex = m_items.size(); for (size_t i = 0; i < m_items.size(); ++i) { Element* test = m_items[i]->requestFocus(nullptr, FocusDirection::None); if (test) { @@ -7191,31 +7171,20 @@ namespace tsl { break; } } - - // Check if we're already at the top with proper tolerance - bool alreadyAtTop = false; - if (firstFocusableIndex < m_items.size()) { - alreadyAtTop = (m_focusedIndex == firstFocusableIndex) && - (std::abs(m_nextOffset - targetOffset) <= tolerance); - } - - if (alreadyAtTop) { - return oldFocus; // Already at top, do nothing - } - - + + const bool alreadyAtTop = (firstFocusableIndex < m_items.size()) && + (m_focusedIndex == firstFocusableIndex) && + (std::abs(m_nextOffset - targetOffset) <= tolerance); + + if (alreadyAtTop) return oldFocus; + const float viewHeight = static_cast(getHeight()); - - // Calculate the target viewport center after skipping const float targetViewportTop = std::max(0.0f, m_offset - viewHeight); - - // Check if we traveled less than a full viewport + const float actualTravelDistance = m_offset - targetViewportTop; const bool traveledFullViewport = (actualTravelDistance >= viewHeight - tolerance); - const float targetViewportCenter = targetViewportTop + (viewHeight / 2.0f + VIEW_CENTER_OFFSET); - // Find the item closest to the center of the new viewport float itemTop = 0.0f; size_t targetIndex = 0; bool foundFocusable = false; @@ -7226,7 +7195,6 @@ namespace tsl { const float itemCenter = itemTop + (itemHeight / 2.0f); const float distanceFromCenter = std::abs(itemCenter - targetViewportCenter); - // Check if this item is focusable and closer to center Element* test = m_items[i]->requestFocus(nullptr, FocusDirection::None); if (test && test->m_isItem && distanceFromCenter < bestDistance) { targetIndex = i; @@ -7237,53 +7205,69 @@ namespace tsl { itemTop += itemHeight; } + const float oldOffset = m_nextOffset; + if (foundFocusable) { - bool nearTop = true; if (targetIndex < m_focusedIndex && traveledFullViewport) { m_focusedIndex = targetIndex; nearTop = false; } - //if (traveledFullViewport) isTableScrolling.store(false, std::memory_order_release); - updateScrollOffset(); // This will center the cursor properly - + updateScrollOffset(); + Element* newFocus = m_items[targetIndex]->requestFocus(oldFocus, FocusDirection::None); - return (newFocus && newFocus != oldFocus && !nearTop && traveledFullViewport) ? newFocus : handleJumpToTop(oldFocus); + + if (newFocus && newFocus != oldFocus && !nearTop && traveledFullViewport) { + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + triggerNavigationFeedback(); + return newFocus; + } else { + return handleJumpToTop(oldFocus); + } } else { + // Scroll viewport even if no focusable items isTableScrolling.store(true, std::memory_order_release); m_nextOffset = targetViewportTop; - - // NEW: Find the first focusable item that's still visible + + if (std::abs(m_nextOffset - oldOffset) > 0.0f) { + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + triggerNavigationFeedback(); + } + + // Focus first visible focusable item float searchItemTop = 0.0f; - size_t firstVisibleFocusable = m_focusedIndex; // Default to current - + size_t firstVisibleFocusable = m_focusedIndex; + for (size_t i = 0; i < m_items.size(); ++i) { const float itemHeight = m_items[i]->getHeight(); const float itemBottom = searchItemTop + itemHeight; - - // Check if this item is visible in the new viewport + if (itemBottom > targetViewportTop && searchItemTop < targetViewportTop + viewHeight) { Element* test = m_items[i]->requestFocus(nullptr, FocusDirection::None); if (test && test->m_isItem) { firstVisibleFocusable = i; - break; // Take the first one for skip up + break; } } - + searchItemTop += itemHeight; } - - // Focus on the first visible focusable item + if (firstVisibleFocusable != m_focusedIndex) { m_focusedIndex = firstVisibleFocusable; Element* newFocus = m_items[m_focusedIndex]->requestFocus(oldFocus, FocusDirection::None); if (newFocus && newFocus != oldFocus) { + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + triggerNavigationFeedback(); return newFocus; } } } - + return oldFocus; } @@ -7362,11 +7346,14 @@ namespace tsl { public: u32 width, height; u64 m_touchStartTime_ns; + bool isLocked = false; #if IS_LAUNCHER_DIRECTIVE ListItem(const std::string& text, const std::string& value = "", bool isMini = false, bool useScriptKey = true) - : Element(), m_text(text), m_value(value), m_listItemHeight(isMini ? tsl::style::MiniListItemDefaultHeight : tsl::style::ListItemDefaultHeight), m_useScriptKey(useScriptKey) { + : Element(), m_text(text), m_value(value), m_listItemHeight(isMini ? tsl::style::MiniListItemDefaultHeight : tsl::style::ListItemDefaultHeight) { m_isItem = true; + m_flags.m_useScriptKey = useScriptKey; + m_flags.m_useClickAnimation = true; m_text_clean = m_text; ult::removeTag(m_text_clean); applyInitialTranslations(); @@ -7376,6 +7363,7 @@ namespace tsl { ListItem(const std::string& text, const std::string& value = "", bool isMini = false) : Element(), m_text(text), m_value(value), m_listItemHeight(isMini ? tsl::style::MiniListItemDefaultHeight : tsl::style::ListItemDefaultHeight) { m_isItem = true; + m_flags.m_useClickAnimation = true; m_text_clean = m_text; ult::removeTag(m_text_clean); applyInitialTranslations(); @@ -7386,16 +7374,14 @@ namespace tsl { virtual ~ListItem() = default; virtual void draw(gfx::Renderer *renderer) override { - const bool useClickTextColor = m_touched && Element::getInputMode() == InputMode::Touch && ult::touchInBounds; + const bool useClickTextColor = m_flags.m_touched && Element::getInputMode() == InputMode::Touch && ult::touchInBounds; if (useClickTextColor) [[unlikely]] { - if (ult::expandedMemory) - renderer->drawRectMultiThreaded(this->getX() + 4, this->getY(), this->getWidth() - 8, this->getHeight(), aWithOpacity(clickColor)); - else - renderer->drawRect(this->getX() + 4, this->getY(), this->getWidth() - 8, this->getHeight(), aWithOpacity(clickColor)); + auto drawFunc = ult::expandedMemory ? &gfx::Renderer::drawRectMultiThreaded : &gfx::Renderer::drawRect; + (renderer->*drawFunc)(this->getX() + 4, this->getY(), this->getWidth() - 8, this->getHeight(), aWithOpacity(clickColor)); } - const s32 yOffset = ((tsl::style::ListItemDefaultHeight - m_listItemHeight) /2.0) +0.5f; // Bit shift for division by 2 + const s16 yOffset = ((tsl::style::ListItemDefaultHeight - m_listItemHeight) >> 1) + 1; if (!m_maxWidth) [[unlikely]] { calculateWidths(renderer); @@ -7415,24 +7401,28 @@ namespace tsl { #if IS_LAUNCHER_DIRECTIVE static const std::vector specialChars = {ult::STAR_SYMBOL}; #else - static const std::vector specialChars = {}; + static const std::vector specialChars = {ult::DIVIDER_SYMBOL}; #endif // Fast path for non-truncated text - if (!m_truncated) [[likely]] { + if (!m_flags.m_truncated) [[likely]] { const Color textColor = m_focused ? (!ult::useSelectionText - ? (m_hasCustomTextColor ? m_customTextColor : defaultTextColor) + ? (m_flags.m_hasCustomTextColor ? m_customTextColor : defaultTextColor) : (useClickTextColor ? clickTextColor : selectedTextColor)) - : (m_hasCustomTextColor + : (m_flags.m_hasCustomTextColor ? m_customTextColor : (useClickTextColor ? clickTextColor : defaultTextColor)); - + #if IS_LAUNCHER_DIRECTIVE renderer->drawStringWithColoredSections(m_text_clean, false, specialChars, this->getX() + 19, this->getY() + 45 - yOffset, 23, textColor, (m_focused ? starColor : selectionStarColor)); + #else + renderer->drawStringWithColoredSections(m_text_clean, false, specialChars, this->getX() + 19, this->getY() + 45 - yOffset, 23, + textColor, textSeparatorColor); + #endif } else { drawTruncatedText(renderer, yOffset, useClickTextColor, specialChars); } @@ -7448,32 +7438,47 @@ namespace tsl { virtual bool onClick(u64 keys) override { if (keys & KEY_A) [[likely]] { - if (m_useClickAnimation) + triggerRumbleClick.store(true, std::memory_order_release); + + if (isLocked) + triggerWallSound.store(true, std::memory_order_release); + else if (m_value.find(ult::CAPITAL_ON_STR) != std::string::npos) + triggerOffSound.store(true, std::memory_order_release); + else if (m_value.find(ult::CAPITAL_OFF_STR) != std::string::npos) + triggerOnSound.store(true, std::memory_order_release); + else + triggerEnterSound.store(true, std::memory_order_release); + + if (m_flags.m_useClickAnimation) triggerClickAnimation(); } else if (keys & (KEY_UP | KEY_DOWN | KEY_LEFT | KEY_RIGHT)) [[unlikely]] { m_clickAnimationProgress = 0; } + //if (keys & KEY_B) { + // triggerRumbleDoubleClick.store(true, std::memory_order_release); + // triggerExitSound.store(true, std::memory_order_release); + // + //} return Element::onClick(keys); } virtual bool onTouch(TouchEvent event, s32 currX, s32 currY, s32 prevX, s32 prevY, s32 initialX, s32 initialY) override { if (event == TouchEvent::Touch) [[likely]] { - if ((m_touched = inBounds(currX, currY))) [[likely]] { + if ((m_flags.m_touched = inBounds(currX, currY))) [[likely]] { m_touchStartTime_ns = armTicksToNs(armGetSystemTick()); } return false; } - if (event == TouchEvent::Release && m_touched) [[likely]] { - m_touched = false; + if (event == TouchEvent::Release && m_flags.m_touched) [[likely]] { + m_flags.m_touched = false; if (Element::getInputMode() == InputMode::Touch) [[likely]] { #if IS_LAUNCHER_DIRECTIVE - const s64 keyToUse = determineKeyOnTouchRelease(m_useScriptKey); - const bool handled = onClick(keyToUse); + const s64 keyToUse = determineKeyOnTouchRelease(m_flags.m_useScriptKey); #else const s64 keyToUse = determineKeyOnTouchRelease(false); - const bool handled = onClick(keyToUse); #endif + const bool handled = onClick(keyToUse); m_clickAnimationProgress = 0; return handled; } @@ -7483,7 +7488,7 @@ namespace tsl { virtual void setFocused(bool state) override { if (state != m_focused) [[likely]] { - m_scroll = false; + m_flags.m_scroll = false; m_scrollOffset = 0; timeIn_ns = armTicksToNs(armGetSystemTick()); Element::setFocused(state); @@ -7505,10 +7510,9 @@ namespace tsl { } inline void setValue(const std::string& value, bool faint = false) { - if (m_value != value || m_faint != faint) [[likely]] { + if (m_value != value || m_flags.m_faint != faint) [[likely]] { m_value = value; - m_faint = faint; - //m_useVersionColor = useVersionColor; + m_flags.m_faint = faint; m_maxWidth = 0; if (!value.empty()) applyInitialTranslations(true); } @@ -7516,30 +7520,29 @@ namespace tsl { inline void setTextColor(Color color) { m_customTextColor = color; - m_hasCustomTextColor = true; + m_flags.m_hasCustomTextColor = true; } inline void setValueColor(Color color) { m_customValueColor = color; - m_hasCustomValueColor = true; + m_flags.m_hasCustomValueColor = true; } inline void clearTextColor() { - m_hasCustomTextColor = false; + m_flags.m_hasCustomTextColor = false; } inline void clearValueColor() { - m_hasCustomValueColor = false; + m_flags.m_hasCustomValueColor = false; } inline void disableClickAnimation() { - m_useClickAnimation = false; + m_flags.m_useClickAnimation = false; } inline void enableClickAnimation() { - m_useClickAnimation = true; + m_flags.m_useClickAnimation = true; } - inline const std::string& getText() const noexcept { return m_text; @@ -7549,10 +7552,6 @@ namespace tsl { return m_value; } - //virtual bool matchesJumpCriteria(const std::string& jumpText, const std::string& jumpValue) const override { - // return matchesJumpCriteria(jumpText, jumpValue, true); // Default to exact match - //} - virtual bool matchesJumpCriteria(const std::string& jumpText, const std::string& jumpValue, bool exactMatch=true) const { if (jumpText.empty() && jumpValue.empty()) return false; @@ -7580,57 +7579,70 @@ namespace tsl { std::string m_value; std::string m_scrollText; std::string m_ellipsisText; - u32 m_listItemHeight; + u16 m_listItemHeight; // Changed from u32 to u16 + + + // Bitfield for boolean flags - saves ~7 bytes per instance + struct { + bool m_scroll : 1; + bool m_truncated : 1; + bool m_faint : 1; + bool m_touched : 1; + bool m_hasCustomTextColor : 1; + bool m_hasCustomValueColor : 1; + bool m_useClickAnimation : 1; + #if IS_LAUNCHER_DIRECTIVE + bool m_useScriptKey : 1; + #endif + } m_flags = {}; - #if IS_LAUNCHER_DIRECTIVE - bool m_useScriptKey = false; - #endif - - bool m_scroll = false; - bool m_truncated = false; - bool m_faint = false; - //bool m_useVersionColor = false; - bool m_touched = false; - - bool m_hasCustomTextColor = false; - bool m_hasCustomValueColor = false; Color m_customTextColor = {0}; Color m_customValueColor = {0}; - bool m_useClickAnimation = true; float m_scrollOffset = 0.0f; - u32 m_maxWidth = 0; - u32 m_textWidth = 0; + u16 m_maxWidth = 0; // Changed from u32 to u16 + u16 m_textWidth = 0; // Changed from u32 to u16 private: + // Consolidated scroll constants struct + struct ScrollConstants { + double totalCycleDuration; + double delayDuration; + double scrollDuration; + double accelTime; + double constantVelocityTime; + double maxVelocity; + double accelDistance; + double constantVelocityDistance; + double minScrollDistance; + double invAccelTime; + double invDecelTime; + double invBillion; + bool initialized = false; + }; + void applyInitialTranslations(bool isValue = false) { std::string& target = isValue ? m_value : m_text_clean; ult::applyLangReplacements(target, isValue); ult::convertComboToUnicode(target); - // Thread-safe translation cache access #ifdef UI_OVERRIDE_PATH { - // Use the processed target as the key for translation lookup const std::string originalKey = target; std::shared_lock readLock(tsl::gfx::s_translationCacheMutex); auto translatedIt = ult::translationCache.find(originalKey); if (translatedIt != ult::translationCache.end()) { - target = translatedIt->second; // Apply translation to target, not text + target = translatedIt->second; } else { - // Need to upgrade to write lock readLock.unlock(); std::unique_lock writeLock(tsl::gfx::s_translationCacheMutex); - // Double-check pattern translatedIt = ult::translationCache.find(originalKey); if (translatedIt != ult::translationCache.end()) { target = translatedIt->second; } else { - // Store the original as both key and value if no translation exists ult::translationCache[originalKey] = originalKey; - // target already contains the correct value, no need to modify } } } @@ -7641,22 +7653,17 @@ namespace tsl { if (m_value.empty()) { m_maxWidth = getWidth() - 62; } else { - //auto valueWidth = renderer->getTextDimensions(m_value, false, 20).first; m_maxWidth = getWidth() - renderer->getTextDimensions(m_value, false, 20).first - 66; } - //auto textWidth = renderer->getTextDimensions(m_text, false, 23).first; - const u32 width = renderer->getTextDimensions(m_text_clean, false, 23).first; - m_truncated = width > m_maxWidth + 20; + const u16 width = renderer->getTextDimensions(m_text_clean, false, 23).first; + m_flags.m_truncated = width > m_maxWidth + 20; - if (m_truncated) [[unlikely]] { - // Optimized string building for scroll text + if (m_flags.m_truncated) [[unlikely]] { m_scrollText.clear(); - m_scrollText.reserve(m_text_clean.size() * 2 + 8); // Pre-allocate for text + spaces + text + m_scrollText.reserve(m_text_clean.size() * 2 + 8); - // Build scroll text efficiently: "text text" m_scrollText.append(m_text_clean).append(" "); - //auto scrollWidth = renderer->getTextDimensions(m_scrollText, false, 23).first; m_textWidth = renderer->getTextDimensions(m_scrollText, false, 23).first; m_scrollText.append(m_text_clean); @@ -7669,121 +7676,93 @@ namespace tsl { void drawTruncatedText(gfx::Renderer* renderer, s32 yOffset, bool useClickTextColor, const std::vector& specialSymbols = {}) { if (m_focused) { renderer->enableScissoring(getX() + 6, 97, m_maxWidth + (m_value.empty() ? 49 : 27), tsl::cfg::FramebufferHeight - 170); - - //Color textColor = m_hasCustomTextColor ? m_customTextColor : - // (useClickTextColor ? clickTextColor : selectedTextColor); - + #if IS_LAUNCHER_DIRECTIVE renderer->drawStringWithColoredSections(m_scrollText, false, specialSymbols, getX() + 19 - static_cast(m_scrollOffset), getY() + 45 - yOffset, 23, !ult::useSelectionText ? defaultTextColor: (useClickTextColor ? clickTextColor : selectedTextColor), (starColor)); + #else + renderer->drawStringWithColoredSections(m_scrollText, false, specialSymbols, getX() + 19 - static_cast(m_scrollOffset), getY() + 45 - yOffset, 23, + !ult::useSelectionText ? defaultTextColor: (useClickTextColor ? clickTextColor : selectedTextColor), (textSeparatorColor)); + #endif renderer->disableScissoring(); handleScrolling(); } else { - //Color textColor = m_hasCustomTextColor ? m_customTextColor : - // (useClickTextColor ? clickTextColor : defaultTextColor); - + #if IS_LAUNCHER_DIRECTIVE renderer->drawStringWithColoredSections(m_ellipsisText, false, specialSymbols, getX() + 19, getY() + 45 - yOffset, 23, - m_hasCustomTextColor ? m_customTextColor : (useClickTextColor ? clickTextColor : defaultTextColor), (starColor)); + m_flags.m_hasCustomTextColor ? m_customTextColor : (useClickTextColor ? clickTextColor : defaultTextColor), (starColor)); + #else + renderer->drawStringWithColoredSections(m_ellipsisText, false, specialSymbols, getX() + 19, getY() + 45 - yOffset, 23, + m_flags.m_hasCustomTextColor ? m_customTextColor : (useClickTextColor ? clickTextColor : defaultTextColor), (textSeparatorColor)); + #endif } } - void handleScrolling() { - const u64 currentTime_ns = armTicksToNs(armGetSystemTick()); - const u64 elapsed_ns = currentTime_ns - timeIn_ns; - - // Frame rate compensation - cache calculations to reduce stutter + static ScrollConstants sc; static u64 lastUpdateTime = 0; static float cachedScrollOffset = 0.0f; - // Pre-compute constants as statics to avoid recalculation - static bool constantsInitialized = false; - static double totalCycleDuration; - static double delayDuration; - static double scrollDuration; - static double accelTime; - static double constantVelocityTime; - static double maxVelocity; - static double accelDistance; - static double constantVelocityDistance; - static double minScrollDistance; - static double invAccelTime; // 1/accelTime for multiplication instead of division - static double invDecelTime; // 1/decelTime for multiplication instead of division - static double invBillion; // 1/1000000000.0 for ns to seconds conversion + const u64 currentTime_ns = armTicksToNs(armGetSystemTick()); + const u64 elapsed_ns = currentTime_ns - timeIn_ns; - if (!constantsInitialized || minScrollDistance != static_cast(m_textWidth)) { - // Constants for velocity-based scrolling - delayDuration = 2.0; + if (!sc.initialized || sc.minScrollDistance != static_cast(m_textWidth)) { + sc.delayDuration = 2.0; static constexpr double pauseDuration = 1.0; - maxVelocity = 166.0; - accelTime = 0.5; + sc.maxVelocity = 166.0; + sc.accelTime = 0.5; static constexpr double decelTime = 0.5; - // Pre-calculate derived constants - minScrollDistance = static_cast(m_textWidth); - accelDistance = 0.5 * maxVelocity * accelTime; - const double decelDistance = 0.5 * maxVelocity * decelTime; - constantVelocityDistance = std::max(0.0, minScrollDistance - accelDistance - decelDistance); - constantVelocityTime = constantVelocityDistance / maxVelocity; - scrollDuration = accelTime + constantVelocityTime + decelTime; - totalCycleDuration = delayDuration + scrollDuration + pauseDuration; + sc.minScrollDistance = static_cast(m_textWidth); + sc.accelDistance = 0.5 * sc.maxVelocity * sc.accelTime; + const double decelDistance = 0.5 * sc.maxVelocity * decelTime; + sc.constantVelocityDistance = std::max(0.0, sc.minScrollDistance - sc.accelDistance - decelDistance); + sc.constantVelocityTime = sc.constantVelocityDistance / sc.maxVelocity; + sc.scrollDuration = sc.accelTime + sc.constantVelocityTime + decelTime; + sc.totalCycleDuration = sc.delayDuration + sc.scrollDuration + pauseDuration; - // Pre-calculate reciprocals for faster division - invAccelTime = 1.0 / accelTime; - invDecelTime = 1.0 / decelTime; - invBillion = 1.0 / 1000000000.0; + sc.invAccelTime = 1.0 / sc.accelTime; + sc.invDecelTime = 1.0 / decelTime; + sc.invBillion = 1.0 / 1000000000.0; - constantsInitialized = true; + sc.initialized = true; } - // Fast ns to seconds conversion - const double elapsed_seconds = static_cast(elapsed_ns) * invBillion; + const double elapsed_seconds = static_cast(elapsed_ns) * sc.invBillion; - // Update at consistent intervals regardless of frame rate - if (currentTime_ns - lastUpdateTime >= 8333333ULL) { // ~120 FPS update rate - // Use std::fmod for modulo - it's optimized and faster than loops - const double cyclePosition = std::fmod(elapsed_seconds, totalCycleDuration); + if (currentTime_ns - lastUpdateTime >= 8333333ULL) { + const double cyclePosition = std::fmod(elapsed_seconds, sc.totalCycleDuration); - if (cyclePosition < delayDuration) [[likely]] { - // Delay phase - no scrolling + if (cyclePosition < sc.delayDuration) [[likely]] { cachedScrollOffset = 0.0f; - } else if (cyclePosition < delayDuration + scrollDuration) [[likely]] { - // Scrolling phase - velocity-based movement - const double scrollTime = cyclePosition - delayDuration; + } else if (cyclePosition < sc.delayDuration + sc.scrollDuration) [[likely]] { + const double scrollTime = cyclePosition - sc.delayDuration; double distance; - if (scrollTime <= accelTime) { - // Acceleration phase - quadratic ease-in - const double t = scrollTime * invAccelTime; // Multiply instead of divide + if (scrollTime <= sc.accelTime) { + const double t = scrollTime * sc.invAccelTime; const double smoothT = t * t; - distance = smoothT * accelDistance; - } else if (scrollTime <= accelTime + constantVelocityTime) { - // Constant velocity phase - const double constantTime = scrollTime - accelTime; - distance = accelDistance + (constantTime * maxVelocity); + distance = smoothT * sc.accelDistance; + } else if (scrollTime <= sc.accelTime + sc.constantVelocityTime) { + const double constantTime = scrollTime - sc.accelTime; + distance = sc.accelDistance + (constantTime * sc.maxVelocity); } else { - // Deceleration phase - quadratic ease-out - const double decelStartTime = accelTime + constantVelocityTime; - const double t = (scrollTime - decelStartTime) * invDecelTime; // Multiply instead of divide + const double decelStartTime = sc.accelTime + sc.constantVelocityTime; + const double t = (scrollTime - decelStartTime) * sc.invDecelTime; const double oneMinusT = 1.0 - t; - const double smoothT = 1.0 - oneMinusT * oneMinusT; // Avoid repeated calculation - distance = accelDistance + constantVelocityDistance + (smoothT * (minScrollDistance - accelDistance - constantVelocityDistance)); + const double smoothT = 1.0 - oneMinusT * oneMinusT; + distance = sc.accelDistance + sc.constantVelocityDistance + (smoothT * (sc.minScrollDistance - sc.accelDistance - sc.constantVelocityDistance)); } - // Use branchless min with conditional move behavior - cachedScrollOffset = static_cast(distance < minScrollDistance ? distance : minScrollDistance); + cachedScrollOffset = static_cast(distance < sc.minScrollDistance ? distance : sc.minScrollDistance); } else [[unlikely]] { - // Pause phase - stay at end cachedScrollOffset = static_cast(m_textWidth); } lastUpdateTime = currentTime_ns; } - // Use cached value for consistent display m_scrollOffset = cachedScrollOffset; - // Reset timer when cycle completes - if (elapsed_seconds >= totalCycleDuration) [[unlikely]] { + if (elapsed_seconds >= sc.totalCycleDuration) [[unlikely]] { timeIn_ns = currentTime_ns; } } @@ -7802,65 +7781,59 @@ namespace tsl { } else { drawThrobber(renderer, xPosition, yPosition, fontSize, textColor); } - lastRunningInterpreter = ult::runningInterpreter.load(std::memory_order_acquire); // Relaxed ordering is sufficient + lastRunningInterpreter = ult::runningInterpreter.load(std::memory_order_acquire); } Color determineValueTextColor(bool useClickTextColor, bool lastRunningInterpreter) const { - // Check if selection value colors should be disabled if (m_focused && ult::useSelectionValue) { - // Use selection colors when focused and selection colors are enabled if (m_value == ult::DROPDOWN_SYMBOL || m_value == ult::OPTION_SYMBOL) { return useClickTextColor ? (clickTextColor) : - (m_faint ? offTextColor : (useClickTextColor ? clickTextColor : (ult::useSelectionText ? selectedTextColor : defaultTextColor))); + (m_flags.m_faint ? offTextColor : (useClickTextColor ? clickTextColor : (ult::useSelectionText ? selectedTextColor : defaultTextColor))); } const bool isRunning = ult::runningInterpreter.load(std::memory_order_acquire) || lastRunningInterpreter; if (isRunning && (m_value.find(ult::DOWNLOAD_SYMBOL) != std::string::npos || m_value.find(ult::UNZIP_SYMBOL) != std::string::npos || m_value.find(ult::COPY_SYMBOL) != std::string::npos)) { - return m_faint ? offTextColor : (inprogressTextColor); + return m_flags.m_faint ? offTextColor : (inprogressTextColor); } if (m_value == ult::INPROGRESS_SYMBOL) { - return m_faint ? offTextColor : (inprogressTextColor); + return m_flags.m_faint ? offTextColor : (inprogressTextColor); } if (m_value == ult::CROSSMARK_SYMBOL) { - return m_faint ? offTextColor : (invalidTextColor); + return m_flags.m_faint ? offTextColor : (invalidTextColor); } - // For normal values when focused, use selectedValueTextColor return useClickTextColor ? clickTextColor : selectedValueTextColor; } - // If focused but selection colors are disabled, or if not focused, use original logic - // Check for custom value color first - if (m_hasCustomValueColor) { + if (m_flags.m_hasCustomValueColor) { return m_customValueColor; } - // Original logic for all other cases if (m_value == ult::DROPDOWN_SYMBOL || m_value == ult::OPTION_SYMBOL) { - return (m_focused ? (useClickTextColor ? clickTextColor : (m_faint ? offTextColor : (ult::useSelectionText ? selectedTextColor : defaultTextColor))) : - (useClickTextColor ? clickTextColor : (m_faint ? offTextColor : defaultTextColor))); + return (m_focused ? (useClickTextColor ? clickTextColor : (m_flags.m_faint ? offTextColor : (ult::useSelectionText ? selectedTextColor : defaultTextColor))) : + (useClickTextColor ? clickTextColor : (m_flags.m_faint ? offTextColor : defaultTextColor))); } const bool isRunning = ult::runningInterpreter.load(std::memory_order_acquire) || lastRunningInterpreter; if (isRunning && (m_value.find(ult::DOWNLOAD_SYMBOL) != std::string::npos || m_value.find(ult::UNZIP_SYMBOL) != std::string::npos || m_value.find(ult::COPY_SYMBOL) != std::string::npos)) { - return m_faint ? offTextColor : (inprogressTextColor); + return m_flags.m_faint ? offTextColor : (inprogressTextColor); } if (m_value == ult::INPROGRESS_SYMBOL) { - return m_faint ? offTextColor : (inprogressTextColor); + return m_flags.m_faint ? offTextColor : (inprogressTextColor); } if (m_value == ult::CROSSMARK_SYMBOL) { - return m_faint ? offTextColor : (invalidTextColor); + return m_flags.m_faint ? offTextColor : (invalidTextColor); } - return (m_faint ? offTextColor : (onTextColor)); + return (m_flags.m_faint ? offTextColor : (onTextColor)); } void drawThrobber(gfx::Renderer* renderer, s32 xPosition, s32 yPosition, s32 fontSize, Color textColor) { @@ -7869,11 +7842,10 @@ namespace tsl { throbberCounter = (throbberCounter + 1) % (10 * ult::THROBBER_SYMBOLS.size()); renderer->drawString(throbberSymbol, false, xPosition, yPosition, fontSize, textColor); } - s64 determineKeyOnTouchRelease(bool useScriptKey) const { const u64 touchDuration_ns = armTicksToNs(armGetSystemTick()) - m_touchStartTime_ns; - const float touchDurationInSeconds = static_cast(touchDuration_ns) * 1e-9f; // More efficient than division + const float touchDurationInSeconds = static_cast(touchDuration_ns) * 1e-9f; #if IS_LAUNCHER_DIRECTIVE if (touchDurationInSeconds >= 0.7f) [[unlikely]] { @@ -7882,14 +7854,12 @@ namespace tsl { } #endif if (touchDurationInSeconds >= 0.3f) [[unlikely]] { - //if (useScriptKey) ult::shortTouchAndRelease.store(true, std::memory_order_release); return useScriptKey ? SCRIPT_KEY : SETTINGS_KEY; } return KEY_A; } - void resetTextProperties() { m_scrollText.clear(); m_ellipsisText.clear(); @@ -8112,12 +8082,9 @@ namespace tsl { // CUSTOM SECTION START (modification for submenu footer color) - //const std::string& value = this->m_value; const s32 xPosition = this->getX() + this->m_maxWidth + 44 + 3; const s32 yPosition = this->getY() + 45 - yOffset; static constexpr s32 fontSize = 20; - //bool isFaint = ; - //bool isFocused = this->m_focused; //static bool lastRunningInterpreter = ult::runningInterpreter.load(std::memory_order_acquire); @@ -8296,8 +8263,8 @@ namespace tsl { * @param onValue Value drawn if the toggle is on * @param offValue Value drawn if the toggle is off */ - ToggleListItem(const std::string& text, bool initialState, const std::string& onValue = ult::ON, const std::string& offValue = ult::OFF, bool isMini = false) - : ListItem(text, "", isMini), m_state(initialState), m_onValue(onValue), m_offValue(offValue) { + ToggleListItem(const std::string& text, bool initialState, const std::string& onValue = ult::ON, const std::string& offValue = ult::OFF, bool isMini = false, bool delayedHandle=false) + : ListItem(text, "", isMini), m_state(initialState), m_onValue(onValue), m_offValue(offValue), m_delayedHandle(delayedHandle) { this->setState(this->m_state); } @@ -8305,15 +8272,36 @@ namespace tsl { virtual bool onClick(u64 keys) override { + #if IS_LAUNCHER_DIRECTIVE + if (ult::runningInterpreter.load(std::memory_order_acquire)) + return false; + #endif + // Handle KEY_A for toggling if (keys & KEY_A) { + triggerRumbleClick.store(true, std::memory_order_release); + if (!this->m_state) + triggerOnSound.store(true, std::memory_order_release); + else + triggerOffSound.store(true, std::memory_order_release); + + this->m_state = !this->m_state; - this->setState(this->m_state); + if (!m_delayedHandle) + this->setState(this->m_state); + this->m_stateChangedListener(this->m_state); - return ListItem::onClick(keys); + + return true; } + //if (keys & KEY_B) { + // triggerRumbleDoubleClick.store(true, std::memory_order_release); + // triggerExitSound.store(true, std::memory_order_release); + // + //} + #if IS_LAUNCHER_DIRECTIVE // Handle SCRIPT_KEY for executing script logic else if (keys & SCRIPT_KEY) { @@ -8342,6 +8330,11 @@ namespace tsl { * @param state State */ virtual inline void setState(bool state) { + #if IS_LAUNCHER_DIRECTIVE + if (ult::runningInterpreter.load(std::memory_order_acquire)) + return; + #endif + this->m_state = state; this->setValue(state ? this->m_onValue : this->m_offValue, !state); } @@ -8362,9 +8355,12 @@ namespace tsl { } #endif + protected: bool m_state = true; + std::string m_onValue, m_offValue; + bool m_delayedHandle = false; std::function m_stateChangedListener = [](bool){}; @@ -8758,38 +8754,44 @@ namespace tsl { const s32 circleCenterX = this->getX() + 59 + handlePos; const s32 circleCenterY = this->getY() + 40 + 16 - 1; static constexpr s32 circleRadius = 16; - + static bool triggerOnce = true; + const bool touchInCircle = (std::abs(initialX - circleCenterX) <= circleRadius) && (std::abs(initialY - circleCenterY) <= circleRadius); - if (event == TouchEvent::Release) { - this->m_interactionLocked = false; + triggerOnce = true; + triggerRumbleDoubleClick.store(true, std::memory_order_release); + triggerOffSound.store(true, std::memory_order_release); touchInSliderBounds = false; return false; } - - if (!this->m_interactionLocked && (touchInCircle || touchInSliderBounds)) { - touchInSliderBounds = true; - if (currX > this->getLeftBound() + 50 && currX < this->getRightBound() && currY > this->getTopBound() && currY < this->getBottomBound()) { - s16 newValue = (static_cast(currX - (this->getX() + 60)) / static_cast(this->getWidth() - 95)) * 100; - - if (newValue < 0) { - newValue = 0; - } else if (newValue > 100) { - newValue = 100; - } - - if (newValue != this->m_value) { - this->m_value = newValue; - this->m_valueChangedListener(this->getProgress()); - } - - return true; + + if (touchInCircle || touchInSliderBounds) { + if (triggerOnce){ + triggerOnce = false; + triggerRumbleClick.store(true, std::memory_order_release); + triggerOnSound.store(true, std::memory_order_release); } - } - else - this->m_interactionLocked = true; + touchInSliderBounds = true; + //if (currX > this->getLeftBound() + 50 && currX < this->getRightBound() && currY > this->getTopBound() && currY < this->getBottomBound()) { + s16 newValue = (static_cast(currX - (this->getX() + 60)) / static_cast(this->getWidth() - 95)) * 100; + + if (newValue < 0) { + newValue = 0; + } else if (newValue > 100) { + newValue = 100; + } + + if (newValue != this->m_value) { + this->m_value = newValue; + this->m_valueChangedListener(this->getProgress()); + } + + return true; + //} + } + return false; } @@ -8804,8 +8806,16 @@ namespace tsl { } virtual void draw(gfx::Renderer *renderer) override { - static float lastBottomBound; + //static float lastBottomBound; + if (touchInSliderBounds) { + m_drawFrameless = true; + drawHighlight(renderer); + } else { + m_drawFrameless = false; + } + + s32 xPos = this->getX() + 59; s32 yPos = this->getY() + 40 + 16 - 1; s32 width = this->getWidth() - 95; @@ -8825,12 +8835,36 @@ namespace tsl { handlePos = (width) * (this->m_value) / (100); } + // Draw step tick marks if this is a step trackbar + if (m_usingStepTrackbar || m_usingNamedStepTrackbar) { + const u8 numSteps = m_numSteps; + const u16 baseX = xPos; + const u16 baseY = this->getY() + 44; + const u8 halfNumSteps = (numSteps - 1) / 2; + const u16 lastStepX = baseX + width - 1; + const float stepSpacing = static_cast(width) / (numSteps - 1); + const auto stepColor = a(trackBarEmptyColor); + + u16 stepX; + for (u8 i = 0; i < numSteps; i++) { + if (i == numSteps - 1) { + stepX = lastStepX; + } else { + stepX = baseX + static_cast(std::round(i * stepSpacing)); + if (i > halfNumSteps) { + stepX -= 1; + } + } + renderer->drawRect(stepX, baseY, 1, 8, stepColor); + } + } + // Draw track bar background drawBar(renderer, xPos, yPos-3, width, trackBarEmptyColor, !m_usingNamedStepTrackbar); if (!this->m_focused) { drawBar(renderer, xPos, yPos-3, handlePos, trackBarFullColor, !m_usingNamedStepTrackbar); - renderer->drawCircle(xPos + handlePos, yPos, 16, true, a(trackBarSliderBorderColor)); + renderer->drawCircle(xPos + handlePos, yPos, 16, true, a(m_drawFrameless ? highlightColor : trackBarSliderBorderColor)); renderer->drawCircle(xPos + handlePos, yPos, 13, true, a((m_unlockedTrackbar || touchInSliderBounds) ? trackBarSliderMalleableColor : trackBarSliderColor)); } else { touchInSliderBounds = false; @@ -8849,9 +8883,9 @@ namespace tsl { std::string valuePart; if (!m_usingNamedStepTrackbar) { - valuePart = (this->m_units == "%" || this->m_units == "°C" || this->m_units == "°F") ? - ult::to_string(this->m_value) + this->m_units : - ult::to_string(this->m_value) + (this->m_units.empty() ? "" : " ") + this->m_units; + valuePart = (m_units.compare("%") == 0 || m_units.compare("°C") == 0 || m_units.compare("°F") == 0) + ? ult::to_string(m_value) + m_units + : ult::to_string(m_value) + (m_units.empty() ? "" : " ") + m_units; } else { valuePart = this->m_selection; } @@ -8868,23 +8902,11 @@ namespace tsl { renderer->drawString(this->m_icon, false, this->getX()+42, this->getY() + 50+2, 23, a(tsl::style::color::ColorText)); } - //renderer->drawRect(this->getX(), this->getY(), this->getWidth(), 1, a(tsl::style::color::ColorFrame)); - //renderer->drawRect(this->getX(), this->getBottomBound(), this->getWidth(), 1, a(tsl::style::color::ColorFrame)); - //u16 handlePos = (this->getWidth() - 95) * static_cast(this->m_value) / 100; - //renderer->drawCircle(this->getX() + 60, this->getY() + 42, 2, true, a(tsl::style::color::ColorHighlight)); - //renderer->drawCircle(this->getX() + 60 + this->getWidth() - 95, this->getY() + 42, 2, true, a(tsl::style::color::ColorFrame)); - //renderer->drawRect(this->getX() + 60 + handlePos, this->getY() + 40, this->getWidth() - 95 - handlePos, 5, a(tsl::style::color::ColorFrame)); - //renderer->drawRect(this->getX() + 60, this->getY() + 40, handlePos, 5, a(tsl::style::color::ColorHighlight)); - // - //renderer->drawCircle(this->getX() + 62 + handlePos, this->getY() + 42, 18, true, a(tsl::style::color::ColorHandle)); - //renderer->drawCircle(this->getX() + 62 + handlePos, this->getY() + 42, 18, false, a(tsl::style::color::ColorFrame)); - - - if (lastBottomBound != this->getTopBound()) + if (m_lastBottomBound != this->getTopBound()) renderer->drawRect(this->getX() + 4+20-1, this->getTopBound(), this->getWidth() + 6 + 10+20 +4, 1, a(separatorColor)); renderer->drawRect(this->getX() + 4+20-1, this->getBottomBound(), this->getWidth() + 6 + 10+20 +4, 1, a(separatorColor)); - lastBottomBound = this->getBottomBound(); + m_lastBottomBound = this->getBottomBound(); } virtual void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override { @@ -8947,21 +8969,30 @@ namespace tsl { y = std::clamp(y, -amplitude, amplitude); } } - - if (ult::useSelectionBG) { - if (ult::expandedMemory) - renderer->drawRectMultiThreaded(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(selectionBGColor)); // CUSTOM MODIFICATION - else - renderer->drawRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(selectionBGColor)); // CUSTOM MODIFICATION - - - //renderer->drawRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), a(selectionBGColor)); // CUSTOM MODIFICATION - } - - renderer->drawBorderedRoundedRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11, this->getHeight(), 5, 5, a(highlightColor)); - if (!ult::onTrackBar.load(std::memory_order_acquire)) - ult::onTrackBar.store(true, std::memory_order_release); + if (!m_drawFrameless) { + if (ult::useSelectionBG) { + if (ult::expandedMemory) + renderer->drawRectMultiThreaded(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(selectionBGColor)); // CUSTOM MODIFICATION + else + renderer->drawRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(selectionBGColor)); // CUSTOM MODIFICATION + + + //renderer->drawRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), a(selectionBGColor)); // CUSTOM MODIFICATION + } + + renderer->drawBorderedRoundedRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11, this->getHeight(), 5, 5, a(highlightColor)); + } else { + if (ult::useSelectionBG) { + if (ult::expandedMemory) + renderer->drawRectMultiThreaded(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(clickColor)); // CUSTOM MODIFICATION + else + renderer->drawRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(clickColor)); // CUSTOM MODIFICATION + } + } + + + ult::onTrackBar.exchange(true, std::memory_order_acq_rel); } /** @@ -9003,11 +9034,15 @@ namespace tsl { bool m_unlockedTrackbar = true; bool touchInSliderBounds = false; + u8 m_numSteps = 101; // V2 Style properties bool m_useV2Style = false; std::string m_label; std::string m_units; std::string m_selection; // Used for named step trackbars + bool m_drawFrameless = false; + + float m_lastBottomBound; }; @@ -9044,8 +9079,14 @@ namespace tsl { if (keysHeld & (KEY_LEFT | KEY_RIGHT)) { if ((tick == 0 || tick > 20) && (tick % 3) == 0) { if (keysHeld & KEY_LEFT && this->m_value > 0) { + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + triggerNavigationFeedback(); this->m_value = std::max(this->m_value - (100 / (this->m_numSteps - 1)), 0); } else if (keysHeld & KEY_RIGHT && this->m_value < 100) { + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + triggerNavigationFeedback(); this->m_value = std::min(this->m_value + (100 / (this->m_numSteps - 1)), 100); } else { return false; @@ -9062,27 +9103,54 @@ namespace tsl { } virtual bool onTouch(TouchEvent event, s32 currX, s32 currY, s32 prevX, s32 prevY, s32 initialX, s32 initialY) override { - if (this->inBounds(initialX, initialY)) { - if (currY > this->getTopBound() && currY < this->getBottomBound()) { - s16 newValue = (static_cast(currX - (this->getX() + 60)) / static_cast(this->getWidth() - 95)) * 100; - - if (newValue < 0) { - newValue = 0; - } else if (newValue > 100) { - newValue = 100; - } else { - newValue = std::round(newValue / (100.0F / (this->m_numSteps - 1))) * (100.0F / (this->m_numSteps - 1)); - } - - if (newValue != this->m_value) { - this->m_value = newValue; - this->m_valueChangedListener(this->getProgress()); - } - - return true; - } + const u16 trackBarWidth = this->getWidth() - 95; + const u16 handlePos = (trackBarWidth * this->m_value) / 100; + const s32 circleCenterX = this->getX() + 59 + handlePos; + const s32 circleCenterY = this->getY() + 40 + 16 - 1; + static constexpr s32 circleRadius = 16; + static bool triggerOnce = true; + + const bool touchInCircle = (std::abs(initialX - circleCenterX) <= circleRadius) && (std::abs(initialY - circleCenterY) <= circleRadius); + + if (event == TouchEvent::Release) { + triggerOnce = true; + triggerRumbleDoubleClick.store(true, std::memory_order_release); + triggerOffSound.store(true, std::memory_order_release); + touchInSliderBounds = false; + return false; } + + if (touchInCircle || touchInSliderBounds) { + if (triggerOnce){ + triggerOnce = false; + triggerRumbleClick.store(true, std::memory_order_release); + triggerOnSound.store(true, std::memory_order_release); + } + touchInSliderBounds = true; + //if (currY > this->getTopBound() && currY < this->getBottomBound()) { + s16 newValue = (static_cast(currX - (this->getX() + 60)) / static_cast(this->getWidth() - 95)) * 100; + + if (newValue < 0) { + newValue = 0; + } else if (newValue > 100) { + newValue = 100; + } else { + newValue = std::round(newValue / (100.0F / (this->m_numSteps - 1))) * (100.0F / (this->m_numSteps - 1)); + } + + if (newValue != this->m_value) { + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + triggerNavigationFeedback(); + this->m_value = newValue; + this->m_valueChangedListener(this->getProgress()); + } + + return true; + //} + } + return false; } @@ -9133,6 +9201,7 @@ namespace tsl { if (!m_stepDescriptions.empty()) { this->m_selection = m_stepDescriptions[0]; } + m_numSteps = m_stepDescriptions.size(); } virtual ~NamedStepTrackBar() {} @@ -9184,59 +9253,103 @@ namespace tsl { } virtual void draw(gfx::Renderer *renderer) override { - // TrackBar width excluding the handle areas - u16 trackBarWidth = this->getWidth() - 95; - - // Base X and Y coordinates - u16 baseX = this->getX() + 59; - const u16 baseY = this->getY() + 44; // 50 - 3 - - s32 iconOffset = 0; - - if (!m_useV2Style && m_icon[0] != '\0') { - s32 iconWidth = 23;//tsl::gfx::calculateStringWidth(m_icon, 23); - iconOffset = 14 + iconWidth; - baseX += iconOffset; - trackBarWidth -= iconOffset; + if (touchInSliderBounds) { + m_drawFrameless = true; + drawHighlight(renderer); + } else { + m_drawFrameless = false; } - - // Calculate the spacing between each step - const float stepSpacing = static_cast(trackBarWidth) / (this->m_numSteps - 1); - - // Calculate the halfway point index - const u8 halfNumSteps = (this->m_numSteps - 1) / 2; - // Draw step rectangles - u16 stepX; - for (u8 i = 0; i < this->m_numSteps; i++) { - stepX = baseX + std::round(i * stepSpacing); - - // Subtract 1 from the X position for steps on the right side of the center - if (i > halfNumSteps) { - stepX -= 1; - } - // Adjust the last step to avoid overshooting - if (i == this->m_numSteps - 1) { - stepX = baseX + trackBarWidth -1; - } - renderer->drawRect(stepX, baseY, 1, 8, a(trackBarEmptyColor)); + s32 xPos = this->getX() + 59; + s32 yPos = this->getY() + 40 + 16 - 1; + s32 width = this->getWidth() - 95; + u16 handlePos = width * (this->m_value) / (100); + + if (!m_usingNamedStepTrackbar) { + yPos -= 11; } - - const u8 currentDescIndex = std::clamp(this->m_value / (100 / (this->m_numSteps - 1)), 0, this->m_numSteps - 1); - - // Update selection for current index - if (currentDescIndex < m_stepDescriptions.size()) { - this->m_selection = m_stepDescriptions[currentDescIndex]; + + s32 iconOffset = 0; + + if (!m_useV2Style && m_icon[0] != '\0') { + s32 iconWidth = 23; + iconOffset = 14 + iconWidth; + xPos += iconOffset; + width -= iconOffset; + handlePos = (width) * (this->m_value) / (100); } - - // Only draw the step description above the bar if not using V2 style (V2 style shows it on the right) - if (!m_useV2Style) { - const auto descWidth = renderer->getTextDimensions(this->m_stepDescriptions[currentDescIndex].c_str(), false, 15).first; - renderer->drawString(this->m_stepDescriptions[currentDescIndex].c_str(), false, ((baseX +1) + (trackBarWidth) / 2) - (descWidth / 2), this->getY() + 20 + 6, 15, (this->m_focused && ult::useSelectionValue) ? selectedValueTextColor : onTextColor); + + // Draw step tick marks if this is a step trackbar + { + const u8 numSteps = m_numSteps; + const u16 baseX = xPos; + const u16 baseY = this->getY() + 44; + const u8 halfNumSteps = (numSteps - 1) / 2; + const u16 lastStepX = baseX + width - 1; + const float stepSpacing = static_cast(width) / (numSteps - 1); + const auto stepColor = a(trackBarEmptyColor); + + u16 stepX; + for (u8 i = 0; i < numSteps; i++) { + if (i == numSteps - 1) { + stepX = lastStepX; + } else { + stepX = baseX + static_cast(std::round(i * stepSpacing)); + if (i > halfNumSteps) { + stepX -= 1; + } + } + renderer->drawRect(stepX, baseY, 1, 8, stepColor); + } } + + // Draw track bar background + drawBar(renderer, xPos, yPos-3, width, trackBarEmptyColor, !m_usingNamedStepTrackbar); + + if (!this->m_focused) { + drawBar(renderer, xPos, yPos-3, handlePos, trackBarFullColor, !m_usingNamedStepTrackbar); + renderer->drawCircle(xPos + handlePos, yPos, 16, true, a(m_drawFrameless ? highlightColor : trackBarSliderBorderColor)); + renderer->drawCircle(xPos + handlePos, yPos, 13, true, a((m_unlockedTrackbar || touchInSliderBounds) ? trackBarSliderMalleableColor : trackBarSliderColor)); + } else { + touchInSliderBounds = false; + if (m_unlockedTrackbar != ult::unlockedSlide.load(std::memory_order_acquire)) + ult::unlockedSlide.store(m_unlockedTrackbar, std::memory_order_release); + drawBar(renderer, xPos, yPos-3, handlePos, trackBarFullColor, !m_usingNamedStepTrackbar); + renderer->drawCircle(xPos + x + handlePos, yPos +y, 16, true, a(highlightColor)); + renderer->drawCircle(xPos + x + handlePos, yPos +y, 12, true, a((ult::allowSlide.load(std::memory_order_acquire) || m_unlockedTrackbar) ? trackBarSliderMalleableColor : trackBarSliderColor)); + } + + // Draw icon (original style) or label + value (V2 style) + if (m_useV2Style) { + // V2 Style: Draw label and value + std::string labelPart = this->m_label; + ult::removeTag(labelPart); - // Draw the parent trackbar - StepTrackBar::draw(renderer); + std::string valuePart; + if (!m_usingNamedStepTrackbar) { + valuePart = (m_units.compare("%") == 0 || m_units.compare("°C") == 0 || m_units.compare("°F") == 0) + ? ult::to_string(m_value) + m_units + : ult::to_string(m_value) + (m_units.empty() ? "" : " ") + m_units; + } else { + valuePart = this->m_selection; + } + + const auto valueWidth = renderer->getTextDimensions(valuePart, false, 16).first; + + renderer->drawString(labelPart, false, this->getX() + 59, this->getY() + 14 + 16, 16, + ((!this->m_focused || !ult::useSelectionText) ? (defaultTextColor) : (selectedTextColor))); + + renderer->drawString(valuePart, false, this->getWidth() -17 - valueWidth, this->getY() + 14 + 16, 16, (this->m_focused && ult::useSelectionValue) ? selectedValueTextColor : onTextColor); + } else { + // Original Style: Draw icon + if (m_icon[0] != '\0') + renderer->drawString(this->m_icon, false, this->getX()+42, this->getY() + 50+2, 23, a(tsl::style::color::ColorText)); + } + + if (m_lastBottomBound != this->getTopBound()) + renderer->drawRect(this->getX() + 4+20-1, this->getTopBound(), this->getWidth() + 6 + 10+20 +4, 1, a(separatorColor)); + renderer->drawRect(this->getX() + 4+20-1, this->getBottomBound(), this->getWidth() + 6 + 10+20 +4, 1, a(separatorColor)); + m_lastBottomBound = this->getBottomBound(); } protected: @@ -9261,13 +9374,10 @@ namespace tsl { s32 amplitude; u32 descWidth, descHeight; - // Add setScriptKeyListener function void setScriptKeyListener(std::function listener) { m_scriptKeyListener = std::move(listener); } - - // Ensure the order of initialization matches the order of declaration TrackBarV2(std::string label, std::string packagePath = "", s16 minValue = 0, s16 maxValue = 100, std::string units = "", std::function>&&, const std::string&, const std::string&)> executeCommands = nullptr, std::function>(const std::vector>&, const std::string&, size_t, const std::string&)> sourceReplacementFunc = nullptr, @@ -9275,61 +9385,59 @@ namespace tsl { : m_label(label), m_packagePath(packagePath), m_minValue(minValue), m_maxValue(maxValue), m_units(units), interpretAndExecuteCommands(executeCommands), getSourceReplacement(sourceReplacementFunc), commands(std::move(cmd)), selectedCommand(selCmd), m_usingStepTrackbar(usingStepTrackbar), m_usingNamedStepTrackbar(usingNamedStepTrackbar), m_numSteps(numSteps), m_unlockedTrackbar(unlockedTrackbar), m_executeOnEveryTick(executeOnEveryTick) { + m_isItem = true; - - if ((!usingStepTrackbar && !usingNamedStepTrackbar) || numSteps == -1) { - m_numSteps = (maxValue - minValue)+1; + + if (maxValue < minValue) { + std::swap(minValue, maxValue); + m_minValue = minValue; + m_maxValue = maxValue; } - + + if ((!usingStepTrackbar && !usingNamedStepTrackbar) || numSteps == -1) { + m_numSteps = (maxValue - minValue) + 1; + } + + if (m_numSteps < 2) { + m_numSteps = 2; + } + bool loadedValue = false; - //if (!m_packagePath.empty()) { - // std::string initialIndex = ult::parseValueFromIniSection(m_packagePath + "config.ini", m_label, "index"); - // - // if (!initialIndex.empty()) { - // m_index = static_cast(ult::stoi(initialIndex)); // convert initializedValue to s16 - // } - // if (!m_usingNamedStepTrackbar) { - // std::string initialValue = ult::parseValueFromIniSection(m_packagePath + "config.ini", m_label, "value"); - // - // if (!initialValue.empty()) { - // m_value = static_cast(ult::stoi(initialValue)); // convert initializedValue to s16 - // loadedValue = true; - // } - // } - //} - + if (!m_packagePath.empty()) { - // Load config INI once and extract both values auto configIniData = ult::getParsedDataFromIniFile(m_packagePath + "config.ini"); auto sectionIt = configIniData.find(m_label); if (sectionIt != configIniData.end()) { - // Get index value auto indexIt = sectionIt->second.find("index"); if (indexIt != sectionIt->second.end() && !indexIt->second.empty()) { - m_index = static_cast(ult::stoi(indexIt->second)); // convert initializedValue to s16 + m_index = static_cast(ult::stoi(indexIt->second)); } - // Get value if not using named step trackbar if (!m_usingNamedStepTrackbar) { auto valueIt = sectionIt->second.find("value"); if (valueIt != sectionIt->second.end() && !valueIt->second.empty()) { - m_value = static_cast(ult::stoi(valueIt->second)); // convert initializedValue to s16 + m_value = static_cast(ult::stoi(valueIt->second)); loadedValue = true; } } } } - - if (m_index > m_numSteps -1) m_index = m_numSteps - 1; - else if (m_index < 0) m_index = 0; - - if (!loadedValue) - m_value = minValue + m_index * (static_cast(maxValue - minValue) / (m_numSteps - 1)); - + + if (m_index >= m_numSteps) m_index = m_numSteps - 1; + if (m_index < 0) m_index = 0; + + if (!loadedValue) { + if (m_numSteps > 1) { + m_value = minValue + m_index * (static_cast(maxValue - minValue) / (m_numSteps - 1)); + } else { + m_value = minValue; + } + } + if (m_value > maxValue) m_value = maxValue; - else if (m_value < minValue) m_value = minValue; - + if (m_value < minValue) m_value = minValue; + lastUpdate_ns = armTicksToNs(armGetSystemTick()); } @@ -9339,7 +9447,6 @@ namespace tsl { return this; } - inline void updateAndExecute(bool updateIni = true) { if (m_packagePath.empty()) { return; @@ -9355,7 +9462,6 @@ namespace tsl { } bool success = false; - // Placeholder replacement - cache lengths once static const std::string valuePlaceholder = "{value}"; static const std::string indexPlaceholder = "{index}"; static const size_t valuePlaceholderLen = valuePlaceholder.length(); @@ -9372,12 +9478,10 @@ namespace tsl { for (auto& cmd : modifiedCmds) { for (auto& arg : cmd) { - // Replace value placeholder for (size_t pos = 0; (pos = arg.find(valuePlaceholder, pos)) != std::string::npos; pos += valueStrLen) { arg.replace(pos, valuePlaceholderLen, valueStr); } - // Replace index placeholder if needed if (m_usingNamedStepTrackbar) { for (size_t pos = 0; (pos = arg.find(indexPlaceholder, pos)) != std::string::npos; pos += indexStrLen) { arg.replace(pos, indexPlaceholderLen, indexStr); @@ -9396,24 +9500,16 @@ namespace tsl { } } - virtual inline bool handleInput(u64 keysDown, u64 keysHeld, const HidTouchState &touchPos, HidAnalogStickState leftJoyStick, HidAnalogStickState rightJoyStick) override { - static bool holding = false; - static u64 holdStartTime_ns; - static u64 prevKeysHeld = 0; - - const u64 keysReleased = prevKeysHeld & ~keysHeld; - prevKeysHeld = keysHeld; + const u64 keysReleased = m_prevKeysHeld & ~keysHeld; + m_prevKeysHeld = keysHeld; const u64 currentTime_ns = armTicksToNs(armGetSystemTick()); const u64 elapsed_ns = currentTime_ns - lastUpdate_ns; - - static bool wasLastHeld = false; - + m_keyRHeld = (keysHeld & KEY_R) != 0; - - if ((keysHeld & KEY_R)) { - //auto currentFocus = currentGui->getFocusedElement(); + + if ((keysHeld & KEY_R)) { if (keysDown & KEY_UP && !(keysHeld & ~KEY_UP & ~KEY_R & ALL_KEYS_MASK)) this->shakeHighlight(FocusDirection::Up); else if (keysDown & KEY_DOWN && !(keysHeld & ~KEY_DOWN & ~KEY_R & ALL_KEYS_MASK)) @@ -9424,17 +9520,18 @@ namespace tsl { else if (keysDown & KEY_RIGHT && !(keysHeld & ~KEY_RIGHT & ~KEY_R & ALL_KEYS_MASK)) { this->shakeHighlight(FocusDirection::Right); } - return true; } - - // Check if KEY_A is pressed to toggle ult::allowSlide + if ((keysDown & KEY_A) && !(keysHeld & ~KEY_A & ALL_KEYS_MASK)) { + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerEnterSound.store(true, std::memory_order_release); + triggerEnterFeedback(); + + if (!m_unlockedTrackbar) { - //ult::allowSlide = !ult::allowSlide; - //ult::allowSlide.fetch_xor(true, std::memory_order_acq_rel); ult::atomicToggle(ult::allowSlide); - holding = false; // Reset holding state when KEY_A is pressed + m_holding = false; } if (m_unlockedTrackbar || (!m_unlockedTrackbar && !ult::allowSlide.load(std::memory_order_acquire))) { updateAndExecute(); @@ -9442,140 +9539,164 @@ namespace tsl { } return true; } - - // Handle SCRIPT_KEY press + + //if (keysDown & KEY_B && !(keysHeld & ~KEY_B & ALL_KEYS_MASK)) { + // triggerRumbleDoubleClick.store(true, std::memory_order_release); + // triggerExitSound.store(true, std::memory_order_release); + //} + if ((keysDown & SCRIPT_KEY) && !(keysHeld & ~SCRIPT_KEY & ALL_KEYS_MASK)) { if (m_scriptKeyListener) { m_scriptKeyListener(); } return true; } - - - // Allow sliding only if KEY_A has been pressed + if (ult::allowSlide.load(std::memory_order_acquire) || m_unlockedTrackbar) { - - if (((keysReleased & KEY_LEFT) || (keysReleased & KEY_RIGHT)) || - (wasLastHeld && !((keysHeld & KEY_LEFT) || (keysHeld & KEY_RIGHT)))) { - - wasLastHeld = false; - updateAndExecute(); - lastUpdate_ns = armTicksToNs(armGetSystemTick()); - - holding = false; - return true; + // Handle key release + if (((keysReleased & KEY_LEFT) || (keysReleased & KEY_RIGHT))) { + // If we were holding and repeating, just stop + if (m_wasLastHeld) { + m_wasLastHeld = false; + //triggerNavigationSound.store(true, std::memory_order_release); + //triggerRumbleClick.store(true, std::memory_order_release); + + m_holding = false; + updateAndExecute(); + lastUpdate_ns = armTicksToNs(armGetSystemTick()); + return true; + } + // If it was a quick tap (no repeat happened), handle the single tick + else if (m_holding) { + m_holding = false; + //triggerNavigationSound.store(true, std::memory_order_release); + //triggerRumbleClick.store(true, std::memory_order_release); + updateAndExecute(); + lastUpdate_ns = armTicksToNs(armGetSystemTick()); + return true; + } } + // Ignore simultaneous left+right if (keysDown & KEY_LEFT && keysDown & KEY_RIGHT) return true; - - if (keysDown & KEY_LEFT) { - if (this->m_value > m_minValue) { + if (keysHeld & KEY_LEFT && keysHeld & KEY_RIGHT) + return true; + + // Handle initial key press + if (keysDown & KEY_LEFT || keysDown & KEY_RIGHT) { + triggerRumbleClick.store(true, std::memory_order_release); + // Start tracking the hold + m_holding = true; + m_wasLastHeld = false; + m_holdStartTime_ns = armTicksToNs(armGetSystemTick()); + lastUpdate_ns = currentTime_ns; + + // Perform the initial single tick + if (keysDown & KEY_LEFT && this->m_value > m_minValue) { this->m_index--; this->m_value--; this->m_valueChangedListener(this->m_value); updateAndExecute(false); - lastUpdate_ns = armTicksToNs(armGetSystemTick()); - return true; - } - } - - if (keysDown & KEY_RIGHT) { - if (this->m_value < m_maxValue) { + } else if (keysDown & KEY_RIGHT && this->m_value < m_maxValue) { this->m_index++; this->m_value++; this->m_valueChangedListener(this->m_value); updateAndExecute(false); - lastUpdate_ns = armTicksToNs(armGetSystemTick()); + } + return true; + } + + // Handle continued holding (after initial press) + if (m_holding && ((keysHeld & KEY_LEFT) || (keysHeld & KEY_RIGHT))) { + const u64 holdDuration_ns = currentTime_ns - m_holdStartTime_ns; + + // Initial delay before repeating starts (e.g., 300ms) + static constexpr u64 initialDelay_ns = 300000000ULL; + // Calculate interval with acceleration + static constexpr u64 initialInterval_ns = 67000000ULL; // ~67ms + static constexpr u64 shortInterval_ns = 10000000ULL; // ~10ms + static constexpr u64 transitionPoint_ns = 1000000000ULL; // 2 seconds + + // Trigger navigation sound every 100ms while holding + static u64 lastNavigationSound_ns = 0; + if (currentTime_ns - lastNavigationSound_ns >= 150'000'000ULL) { // 100ms + if (this->m_value > m_minValue && this->m_value < m_maxValue) { + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + triggerNavigationFeedback(); + + } + lastNavigationSound_ns = currentTime_ns; + } + + // If we haven't passed the initial delay, don't repeat yet + if (holdDuration_ns < initialDelay_ns) { return true; } - } - - - - if (keysHeld & KEY_LEFT && keysHeld & KEY_RIGHT) - return true; - - // Check if the button is being held down - if (((keysHeld & KEY_LEFT) || (keysHeld & KEY_RIGHT))) { - if (!holding) { - holding = true; - holdStartTime_ns = armTicksToNs(armGetSystemTick()); - } - - const u64 holdDuration_ns = currentTime_ns - holdStartTime_ns; - - // Define the duration boundaries in nanoseconds - static constexpr u64 initialInterval_ns = 67000000ULL; // 67ms in nanoseconds - static constexpr u64 shortInterval_ns = 10000000ULL; // 10ms in nanoseconds - static constexpr u64 transitionPoint_ns = 2000000000ULL; // 2000ms in nanoseconds - - // Calculate transition factor (t) from 0 to 1 based on how far we are from the transition point - const float t = std::min(1.0f, static_cast(holdDuration_ns) / static_cast(transitionPoint_ns)); - - // Smooth transition between intervals + const u64 holdDurationAfterDelay_ns = holdDuration_ns - initialDelay_ns; + const float t = std::min(1.0f, static_cast(holdDurationAfterDelay_ns) / static_cast(transitionPoint_ns)); const u64 currentInterval_ns = static_cast((initialInterval_ns - shortInterval_ns) * (1.0f - t) + shortInterval_ns); if (elapsed_ns >= currentInterval_ns) { - if (keysHeld & KEY_LEFT) { - if (this->m_value > m_minValue) { - this->m_index--; - this->m_value--; - this->m_valueChangedListener(this->m_value); - if (m_executeOnEveryTick) { - updateAndExecute(false); - } - lastUpdate_ns = armTicksToNs(armGetSystemTick()); - wasLastHeld = true; - return true; + if (keysHeld & KEY_LEFT && this->m_value > m_minValue) { + this->m_index--; + this->m_value--; + this->m_valueChangedListener(this->m_value); + if (m_executeOnEveryTick) { + updateAndExecute(false); } + lastUpdate_ns = currentTime_ns; + m_wasLastHeld = true; + return true; } - if (keysHeld & KEY_RIGHT) { - if (this->m_value < m_maxValue) { - this->m_index++; - this->m_value++; - this->m_valueChangedListener(this->m_value); - if (m_executeOnEveryTick) { - updateAndExecute(false); - } - lastUpdate_ns = armTicksToNs(armGetSystemTick()); - wasLastHeld = true; - return true; + if (keysHeld & KEY_RIGHT && this->m_value < m_maxValue) { + this->m_index++; + this->m_value++; + this->m_valueChangedListener(this->m_value); + if (m_executeOnEveryTick) { + updateAndExecute(false); } + lastUpdate_ns = currentTime_ns; + m_wasLastHeld = true; + return true; } } } else { - holding = false; // Reset holding state if no relevant key is held + m_holding = false; } } return false; } - - + virtual bool onTouch(TouchEvent event, s32 currX, s32 currY, s32 prevX, s32 prevY, s32 initialX, s32 initialY) override { const u16 trackBarWidth = this->getWidth() - 95; const u16 handlePos = (trackBarWidth * (this->m_value - m_minValue)) / (m_maxValue - m_minValue); const s32 circleCenterX = this->getX() + 59 + handlePos; const s32 circleCenterY = this->getY() + 40 + 16 - 1; static constexpr s32 circleRadius = 16; + static bool triggerOnce = true; const bool touchInCircle = (std::abs(initialX - circleCenterX) <= circleRadius) && (std::abs(initialY - circleCenterY) <= circleRadius); - if (!m_unlockedTrackbar && !ult::allowSlide.load(std::memory_order_acquire)) + if (!m_unlockedTrackbar && !ult::allowSlide.load(std::memory_order_acquire)) { + return false; - + } + if ((touchInCircle || touchInSliderBounds)) { - touchInSliderBounds = true; + + if (triggerOnce) { + triggerOnce = false; + triggerRumbleClick.store(true, std::memory_order_release); + triggerOnSound.store(true, std::memory_order_release); + } - //s16 newIndex = static_cast((currX - (this->getX() + 59)) / static_cast(this->getWidth() - 95) * (m_numSteps - 1)); - - // Clamp the index within valid range const s16 newIndex = std::max(static_cast(0), std::min(static_cast((currX - (this->getX() + 59)) / static_cast(this->getWidth() - 95) * (m_numSteps - 1)), static_cast(m_numSteps - 1))); - const s16 newValue = m_minValue + newIndex * (static_cast(m_maxValue - m_minValue) / (m_numSteps - 1)); if (newValue != this->m_value || newIndex != this->m_index) { @@ -9585,11 +9706,20 @@ namespace tsl { if (m_executeOnEveryTick) { updateAndExecute(false); } + if (m_usingStepTrackbar || m_usingNamedStepTrackbar) { + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + triggerNavigationFeedback(); + } } else { if (event == TouchEvent::Release) { + triggerOnce = true; updateAndExecute(); if (event == TouchEvent::Release) touchInSliderBounds = false; + + triggerRumbleDoubleClick.store(true, std::memory_order_release); + triggerOffSound.store(true, std::memory_order_release); } } @@ -9599,7 +9729,6 @@ namespace tsl { return false; } - // Define drawBar function outside the draw method void drawBar(gfx::Renderer *renderer, s32 x, s32 y, u16 width, Color& color, bool isRounded = true) { if (isRounded) { renderer->drawUniformRoundedRect(x, y, width, 7, a(color)); @@ -9609,24 +9738,27 @@ namespace tsl { } virtual void draw(gfx::Renderer *renderer) override { - static float lastBottomBound; const u16 handlePos = (this->getWidth() - 95) * (this->m_value - m_minValue) / (m_maxValue - m_minValue); const s32 xPos = this->getX() + 59; const s32 yPos = this->getY() + 40 + 16 - 1; const s32 width = this->getWidth() - 95; - - - // Draw track bar background + + const bool shouldAppearLocked = m_unlockedTrackbar && m_keyRHeld; + const bool visuallyUnlocked = (m_unlockedTrackbar && !m_keyRHeld) || touchInSliderBounds; + + if (visuallyUnlocked && touchInSliderBounds) { + m_drawFrameless = true; + drawHighlight(renderer); + } else { + m_drawFrameless = false; + } + drawBar(renderer, xPos, yPos-3, width, trackBarEmptyColor, !m_usingNamedStepTrackbar); - // Determine visual appearance: look locked if KEY_R is held and trackbar is unlocked - const bool shouldAppearLocked = m_unlockedTrackbar && m_keyRHeld; - const bool visuallyUnlocked = (m_unlockedTrackbar && !m_keyRHeld) || touchInSliderBounds; - if (!this->m_focused) { drawBar(renderer, xPos, yPos-3, handlePos, trackBarFullColor, !m_usingNamedStepTrackbar); - renderer->drawCircle(xPos + handlePos, yPos, 16, true, a(trackBarSliderBorderColor)); + renderer->drawCircle(xPos + handlePos, yPos, 16, true, a(!m_drawFrameless ? trackBarSliderBorderColor : highlightColor)); renderer->drawCircle(xPos + handlePos, yPos, 13, true, a(visuallyUnlocked ? trackBarSliderMalleableColor : trackBarSliderColor)); } else { touchInSliderBounds = false; @@ -9634,7 +9766,6 @@ namespace tsl { ult::unlockedSlide.store(m_unlockedTrackbar, std::memory_order_release); drawBar(renderer, xPos, yPos-3, handlePos, trackBarFullColor, !m_usingNamedStepTrackbar); renderer->drawCircle(xPos + x + handlePos, yPos +y, 16, true, a(highlightColor)); - // For focused state, check both allowSlide and visual unlock state const bool focusedVisuallyUnlocked = (ult::allowSlide.load(std::memory_order_acquire) || m_unlockedTrackbar) && !shouldAppearLocked; renderer->drawCircle(xPos + x + handlePos, yPos +y, 12, true, a(focusedVisuallyUnlocked ? trackBarSliderMalleableColor : trackBarSliderColor)); } @@ -9642,70 +9773,58 @@ namespace tsl { std::string labelPart = this->m_label; ult::removeTag(labelPart); - static std::string valuePart; - if (!m_usingNamedStepTrackbar) - valuePart = (this->m_units == "%" || this->m_units == "°C" || this->m_units == "°F") ? ult::to_string(this->m_value) + this->m_units : ult::to_string(this->m_value) + (this->m_units.empty() ? "" : " ") + this->m_units; - else - valuePart = this->m_selection; + if (!m_usingNamedStepTrackbar) { + m_valuePart = (this->m_units.compare("%") == 0 || this->m_units.compare("°C") == 0 || this->m_units.compare("°F") == 0) + ? ult::to_string(this->m_value) + this->m_units + : ult::to_string(this->m_value) + (this->m_units.empty() ? "" : " ") + this->m_units; + } else + m_valuePart = this->m_selection; - const auto valueWidth = renderer->getTextDimensions(valuePart, false, 16).first; + const auto valueWidth = renderer->getTextDimensions(m_valuePart, false, 16).first; renderer->drawString(labelPart, false, xPos, this->getY() + 14 + 16, 16, ((!this->m_focused || !ult::useSelectionText) ? (defaultTextColor) : (selectedTextColor))); - //renderer->drawString(valuePart, false, this->getWidth() -17 - valueWidth, this->getY() + 14 + 16, 16, (onTextColor)); - renderer->drawString(valuePart, false, this->getWidth() -17 - valueWidth, this->getY() + 14 + 16, 16, + renderer->drawString(m_valuePart, false, this->getWidth() -17 - valueWidth, this->getY() + 14 + 16, 16, (this->m_focused && ult::useSelectionValue) ? selectedValueTextColor : onTextColor); - - if (lastBottomBound != this->getTopBound()) + if (m_lastBottomBound != this->getTopBound()) renderer->drawRect(this->getX() + 4+20-1, this->getTopBound(), this->getWidth() + 6 + 10+20 +4, 1, a(separatorColor)); renderer->drawRect(this->getX() + 4+20-1, this->getBottomBound(), this->getWidth() + 6 + 10+20 +4, 1, a(separatorColor)); - lastBottomBound = this->getBottomBound(); + m_lastBottomBound = this->getBottomBound(); } - virtual void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override { this->setBoundaries(this->getX() - 16 , this->getY(), this->getWidth()+20+4, tsl::style::TrackBarDefaultHeight ); } virtual void drawFocusBackground(gfx::Renderer *renderer) { - // No background drawn here in HOS } virtual void drawHighlight(gfx::Renderer *renderer) override { - - // Calculate progress using ARM ticks instead of chrono const u64 currentTime_ns = armTicksToNs(armGetSystemTick()); const double timeInSeconds = static_cast(currentTime_ns) / 1000000000.0; progress = ((std::cos(2.0 * ult::_M_PI * std::fmod(timeInSeconds, 1.0) - ult::_M_PI / 2) + 1.0) / 2.0); - static u64 clickStartTime_ns; - static bool clickActive = false; - Color clickColor1 = highlightColor1; Color clickColor2 = clickColor; - // Activate `clickStartTime_ns` when `triggerClick` is set to true - if (triggerClick && !clickActive) { - clickStartTime_ns = currentTime_ns; - clickActive = true; - // Within the cycle, perform the highlight effect + if (triggerClick && !m_clickActive) { + m_clickStartTime_ns = currentTime_ns; + m_clickActive = true; if (progress >= 0.5) { clickColor1 = clickColor; clickColor2 = highlightColor2; } } - static auto lastLabel = m_label; - if (lastLabel != m_label) { - clickActive = false; + if (m_lastLabel != m_label) { + m_clickActive = false; triggerClick = false; } - lastLabel = m_label; + m_lastLabel = m_label; - if (clickActive) { - const u64 elapsedTime_ns = currentTime_ns - clickStartTime_ns; - if (elapsedTime_ns < 500000000ULL) { // 500ms in nanoseconds - // High precision floating point color interpolation for click colors + if (m_clickActive) { + const u64 elapsedTime_ns = currentTime_ns - m_clickStartTime_ns; + if (elapsedTime_ns < 500000000ULL) { highlightColor = { static_cast((clickColor1.r - clickColor2.r) * progress + clickColor2.r + 0.5), static_cast((clickColor1.g - clickColor2.g) * progress + clickColor2.g + 0.5), @@ -9713,17 +9832,13 @@ namespace tsl { 0xF }; } else { - // End the effect after one cycle - clickActive = false; + m_clickActive = false; triggerClick = false; } - } else { - // Determine if should appear locked: unlocked trackbar with KEY_R held const bool shouldAppearLocked = m_unlockedTrackbar && m_keyRHeld; if ((ult::allowSlide.load(std::memory_order_acquire) || m_unlockedTrackbar) && !shouldAppearLocked) { - // High precision floating point color interpolation for unlocked trackbar highlightColor = { static_cast((highlightColor1.r - highlightColor2.r) * progress + highlightColor2.r + 0.5), static_cast((highlightColor1.g - highlightColor2.g) * progress + highlightColor2.g + 0.5), @@ -9731,7 +9846,6 @@ namespace tsl { 0xF }; } else { - // High precision floating point color interpolation for locked trackbar (or visually locked) highlightColor = { static_cast((highlightColor3.r - highlightColor4.r) * progress + highlightColor4.r + 0.5), static_cast((highlightColor3.g - highlightColor4.g) * progress + highlightColor4.g + 0.5), @@ -9745,9 +9859,8 @@ namespace tsl { y = 0; if (this->m_highlightShaking) { - //const u64 currentTime_ns = armTicksToNs(armGetSystemTick()); t_ns = currentTime_ns - this->m_highlightShakingStartTime; - if (t_ns >= 100000000ULL) // 100ms in nanoseconds + if (t_ns >= 100000000ULL) this->m_highlightShaking = false; else { amplitude = std::rand() % 5 + 5; @@ -9774,26 +9887,33 @@ namespace tsl { } } - if (ult::useSelectionBG) { - if (ult::expandedMemory) - renderer->drawRectMultiThreaded(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(selectionBGColor)); // CUSTOM MODIFICATION - else - renderer->drawRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(selectionBGColor)); // CUSTOM MODIFICATION + + if (!m_drawFrameless) { + if (ult::useSelectionBG) { + if (ult::expandedMemory) + renderer->drawRectMultiThreaded(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(selectionBGColor)); + else + renderer->drawRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(selectionBGColor)); + } + + renderer->drawBorderedRoundedRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11, this->getHeight(), 5, 5, a(highlightColor)); + } else { + if (ult::useSelectionBG) { + if (ult::expandedMemory) + renderer->drawRectMultiThreaded(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(clickColor)); + else + renderer->drawRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(clickColor)); + } - //renderer->drawRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), a(selectionBGColor)); // CUSTOM MODIFICATION } - - renderer->drawBorderedRoundedRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11, this->getHeight(), 5, 5, a(highlightColor)); ult::onTrackBar.store(true, std::memory_order_release); - if (clickActive) { - const u64 elapsedTime_ns = currentTime_ns - clickStartTime_ns; + if (m_clickActive) { + const u64 elapsedTime_ns = currentTime_ns - m_clickStartTime_ns; - // Handle click animation progress and animColor rendering - auto clickAnimationProgress = tsl::style::ListItemHighlightLength * (1.0f - (static_cast(elapsedTime_ns) / 500000000.0f)); // 500ms in nanoseconds + auto clickAnimationProgress = tsl::style::ListItemHighlightLength * (1.0f - (static_cast(elapsedTime_ns) / 500000000.0f)); - // Ensure progress does not go below 0 if (clickAnimationProgress < 0.0f) { clickAnimationProgress = 0.0f; } @@ -9834,15 +9954,14 @@ namespace tsl { std::string m_packagePath; std::string m_selection; s16 m_value = 0; - s16 m_minValue; - s16 m_maxValue; + s16 m_minValue = 0; + s16 m_maxValue = 100; std::string m_units; bool m_interactionLocked = false; - bool m_keyRHeld = false; // Track KEY_R state for visual appearance + bool m_keyRHeld = false; std::function m_valueChangedListener = [](u8) {}; - // New member variables to store the function and its parameters std::function>&&, const std::string&, const std::string&)> interpretAndExecuteCommands; std::function>(const std::vector>&, const std::string&, size_t, const std::string&)> getSourceReplacement; std::vector> commands; @@ -9857,7 +9976,18 @@ namespace tsl { bool touchInSliderBounds = false; bool triggerClick = false; std::function m_scriptKeyListener; - + + // Instance variables replacing static ones + float m_lastBottomBound = 0.0f; + std::string m_valuePart = ""; + u64 m_clickStartTime_ns = 0; + bool m_clickActive = false; + std::string m_lastLabel = ""; + bool m_holding = false; + u64 m_holdStartTime_ns = 0; + u64 m_prevKeysHeld = 0; + bool m_wasLastHeld = false; + bool m_drawFrameless = false; }; @@ -9911,6 +10041,11 @@ namespace tsl { // Check if KEY_A is pressed to toggle ult::allowSlide if ((keysDown & KEY_A) && !(keysHeld & ~KEY_A & ALL_KEYS_MASK)) { + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerEnterSound.store(true, std::memory_order_release); + triggerEnterFeedback(); + + if (!m_unlockedTrackbar) { ult::atomicToggle(ult::allowSlide); holding = false; // Reset holding state when KEY_A is pressed @@ -9922,6 +10057,11 @@ namespace tsl { return true; } + //if (keysDown & KEY_B && !(keysHeld & ~KEY_B & ALL_KEYS_MASK)) { + // triggerRumbleDoubleClick.store(true, std::memory_order_release); + // triggerExitSound.store(true, std::memory_order_release); + //} + // Handle SCRIPT_KEY press if ((keysDown & SCRIPT_KEY) && !(keysHeld & ~SCRIPT_KEY & ALL_KEYS_MASK)) { if (m_scriptKeyListener) { @@ -9954,9 +10094,17 @@ namespace tsl { if ((tick == 0 || tick > 20) && (tick % 3) == 0) { const float stepSize = static_cast(m_maxValue - m_minValue) / (this->m_numSteps - 1); if (keysHeld & KEY_LEFT && this->m_index > 0) { + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + triggerNavigationFeedback(); + this->m_index--; this->m_value = static_cast(std::round(m_minValue + m_index * stepSize)); } else if (keysHeld & KEY_RIGHT && this->m_index < this->m_numSteps-1) { + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerNavigationSound.store(true, std::memory_order_release); + triggerNavigationFeedback(); + this->m_index++; this->m_value = static_cast(std::round(m_minValue + m_index * stepSize)); } else { @@ -10092,6 +10240,13 @@ namespace tsl { static inline std::mutex notificationJsonMutex; static inline std::atomic notificationGeneration{0}; + struct NotificationFile { + std::string filename; + std::string fullPath; + time_t creationTime; + int priority; + }; + class NotificationPrompt { public: NotificationPrompt() @@ -10296,7 +10451,7 @@ namespace tsl { line, false, x + (copy.promptWidth - lw) / 2, startY + static_cast(i) * fm.lineHeight, - copy.fontSize, defaultTextColor + copy.fontSize, notificationTextColor ); } #else @@ -10306,7 +10461,7 @@ namespace tsl { line, false, x + (copy.promptWidth - lw) / 2, startY + static_cast(i) * fm.lineHeight, - copy.fontSize, defaultTextColor + copy.fontSize, notificationTextColor ); #endif } @@ -10340,18 +10495,17 @@ namespace tsl { if (ultrahandPos == std::string::npos) { // Fallback to normal drawing if not found const auto [lw, lh] = renderer->getNotificationTextDimensions(line, false, fontSize); - renderer->drawNotificationString(line, false, x + (promptWidth - lw) / 2, y, fontSize, defaultTextColor); + renderer->drawNotificationString(line, false, x + (promptWidth - lw) / 2, y, fontSize, notificationTextColor); return; } // Split the line into parts const std::string before = line.substr(0, ultrahandPos); - const std::string ultra = ult::SPLIT_PROJECT_NAME_1; const std::string hand = ult::SPLIT_PROJECT_NAME_2; const std::string after = line.substr(ultrahandPos + ultrahandToReplace.length()); // Calculate individual part widths to get accurate total width - s32 beforeWidth = 0, ultraWidth = 0, handWidth = 0, afterWidth = 0; + s32 beforeWidth = 0, handWidth = 0, afterWidth = 0; if (!before.empty()) { const auto [bw, bh] = renderer->getNotificationTextDimensions(before, false, fontSize); @@ -10366,18 +10520,8 @@ namespace tsl { const auto [hw, hh] = renderer->getNotificationTextDimensions(hand, false, fontSize); handWidth = hw; - // For "Ultra" width, we need to handle dynamic vs static rendering differently - if (ult::useDynamicLogo) { - // Calculate width by measuring each character (since dynamic rendering might have slight differences) - for (const char letter : ultra) { - const std::string letterStr(1, letter); - const auto [lw, lh] = renderer->getNotificationTextDimensions(letterStr, false, fontSize); - ultraWidth += lw; - } - } else { - const auto [uw, uh] = renderer->getNotificationTextDimensions(ultra, false, fontSize); - ultraWidth = uw; - } + // Use shared utility to calculate Ultra width + const s32 ultraWidth = tsl::elm::calculateUltraTextWidth(renderer, fontSize, true); // Calculate total width and starting position for centering const s32 totalWidth = beforeWidth + ultraWidth + handWidth + afterWidth; @@ -10387,45 +10531,12 @@ namespace tsl { // Draw "before" part if (!before.empty()) { - renderer->drawNotificationString(before, false, currentX, y, fontSize, defaultTextColor); + renderer->drawNotificationString(before, false, currentX, y, fontSize, notificationTextColor); currentX += beforeWidth; } - // Draw dynamic "Ultra" part - if (ult::useDynamicLogo) { - const u64 currentTime_ns = armTicksToNs(armGetSystemTick()); - const double currentTimeCount = static_cast(currentTime_ns) / 1000000000.0; - const double timeBase = std::fmod(currentTimeCount, cycleDuration); - const double waveScale = 2.0 * ult::_M_PI / cycleDuration; - static constexpr double phaseShift = ult::_M_PI / 2.0; - - float countOffset = 0; - for (const char letter : ultra) { - const double wavePhase = waveScale * (timeBase + static_cast(countOffset)); - const double rawProgress = std::cos(wavePhase - phaseShift); - - const double normalizedProgress = (rawProgress + 1.0) * 0.5; - const double smoothedProgress = normalizedProgress * normalizedProgress * (3.0 - 2.0 * normalizedProgress); - const double ultraSmoothProgress = smoothedProgress * smoothedProgress * (3.0 - 2.0 * smoothedProgress); - - const double blend = std::max(0.0, std::min(1.0, ultraSmoothProgress)); - - const tsl::Color highlightColor = { - static_cast(dynamicLogoRGB1.r + (dynamicLogoRGB2.r - dynamicLogoRGB1.r) * blend + 0.5), - static_cast(dynamicLogoRGB1.g + (dynamicLogoRGB2.g - dynamicLogoRGB1.g) * blend + 0.5), - static_cast(dynamicLogoRGB1.b + (dynamicLogoRGB2.b - dynamicLogoRGB1.b) * blend + 0.5), - 15 - }; - - const std::string letterStr(1, letter); - const auto [letterWidth, letterHeight] = renderer->drawNotificationString(letterStr, false, currentX, y, fontSize, highlightColor); - currentX += letterWidth; - countOffset -= static_cast(cycleDuration / 8.0); - } - } else { - renderer->drawNotificationString(ultra, false, currentX, y, fontSize, logoColor1); - currentX += ultraWidth; - } + // Draw dynamic "Ultra" part using shared utility + currentX = tsl::elm::drawDynamicUltraText(renderer, currentX, y, fontSize, logoColor1, true); // Draw static "hand" part renderer->drawNotificationString(hand, false, currentX, y, fontSize, logoColor2); @@ -10433,7 +10544,7 @@ namespace tsl { // Draw "after" part if (!after.empty()) { - renderer->drawNotificationString(after, false, currentX, y, fontSize, defaultTextColor); + renderer->drawNotificationString(after, false, currentX, y, fontSize, notificationTextColor); } } #endif @@ -10448,17 +10559,6 @@ namespace tsl { (!is_active_ && current_state_.activeText.empty() && pending_queue_.empty())) { return; } - - //if (pending_event_fire_.load(std::memory_order_acquire) && - // !ult::launchingOverlay.load(std::memory_order_acquire) && - // generation_ == notificationGeneration.load(std::memory_order_acquire)) - //{ - // pending_event_fire_.store(false, std::memory_order_release); - // - // if ((current_state_.activeText.empty() || current_state_.state == PromptState::Inactive) && pending_queue_.empty()) { - // eventFire(¬ificationEvent); - // } - //} //std::lock_guard lg(state_mutex_); if (generation_ != notificationGeneration.load(std::memory_order_acquire) || @@ -10555,7 +10655,7 @@ namespace tsl { private: static constexpr size_t MAX_NOTIFS = 30; static constexpr u32 SLIDE_DURATION_MS = 200; - static constexpr double cycleDuration = 1.6; + //static constexpr double cycleDuration = 1.6; mutable std::mutex state_mutex_; NotificationState current_state_; @@ -10838,6 +10938,7 @@ namespace tsl { * */ void show() { + if (this->m_disableNextAnimation) { this->m_animationCounter = MAX_ANIMATION_COUNTER; @@ -10850,6 +10951,11 @@ namespace tsl { ult::isHidden.store(false); this->onShow(); + triggerRumbleClick.store(true, std::memory_order_release); + + // reinitialize audio for changes from handheld to docked and vise versa + if (ult::expandedMemory && ult::useSoundEffects) + ult::AudioPlayer::reloadIfDockedChanged(); //if (auto& currGui = this->getCurrentGui(); currGui != nullptr) // TESTING DISABLED (EFFECTS NEED TO BE VERIFIED) // currGui->restoreFocus(); @@ -10860,12 +10966,15 @@ namespace tsl { * */ void hide(bool useNoFade = false) { + + if (useNoFade) { // Immediately hide overlay ult::isHidden.store(true); this->m_shouldHide = true; return; } + #if IS_STATUS_MONITOR_DIRECTIVE if (FullMode && !deactivateOriginalFooter) { @@ -10894,6 +11003,7 @@ namespace tsl { ult::isHidden.store(true); this->onHide(); #endif + triggerRumbleClick.store(true, std::memory_order_release); } /** @@ -11075,57 +11185,61 @@ namespace tsl { return; } - // Static state management - made atomic for thread safety - static std::atomic screenshotStacksAdded{false}; + // CRITICAL: Initialize to TRUE because stacks are added in init()! + static std::atomic screenshotStacksAdded{true}; static std::atomic notificationCacheNeedsClearing{false}; - + auto& renderer = gfx::Renderer::get(); renderer.startFrame(); // Handle main UI rendering if (!promptOnly) { - // Screenshot management - thread-safe - if (!screenshotStacksAdded.load(std::memory_order_acquire)) { - renderer.addScreenshotStacks(); - screenshotStacksAdded.store(true, std::memory_order_release); + + // In normal mode, ensure screenshots are enabled + // Only re-add if they were removed AND force-disable is not set + if (!screenshotStacksAdded.load(std::memory_order_acquire) && + !screenshotsAreForceDisabled.load(std::memory_order_acquire)) { + if (!screenshotStacksAdded.exchange(true, std::memory_order_acq_rel)) { + renderer.addScreenshotStacks(false); + } } - + this->animationLoop(); this->getCurrentGui()->update(); this->getCurrentGui()->draw(&renderer); - // Mark that we may need to clear notification cache later - notificationCacheNeedsClearing.store(true, std::memory_order_release); + //notificationCacheNeedsClearing.store(true, std::memory_order_release); } else { - // Prompt-only mode - clean up screenshots - if (screenshotStacksAdded.load(std::memory_order_acquire) && !screenshotsAreDisabled) { - renderer.removeScreenshotStacks(); - screenshotStacksAdded.store(false, std::memory_order_release); + // Prompt-only mode - temporarily remove screenshots + if (screenshotStacksAdded.load(std::memory_order_acquire) && + !screenshotsAreDisabled.load(std::memory_order_acquire) && + !screenshotsAreForceDisabled.load(std::memory_order_acquire)) { + + if (screenshotStacksAdded.exchange(false, std::memory_order_acq_rel)) { + renderer.removeScreenshotStacks(false); + } } renderer.clearScreen(); } - // Notification handling - safer approach with consistent ordering + // Notification handling — safe, consistent, and null-guarded { - if (notification) { - - if (notification->isActive()) { - // Snapshot pointer to avoid it becoming null mid-use - notification->update(); - notification->draw(&renderer, promptOnly); - notificationCacheNeedsClearing.store(true, std::memory_order_release); - } else { - if (notificationCacheNeedsClearing.exchange(false, std::memory_order_acq_rel)) { - tsl::gfx::FontManager::clearNotificationCache(); - #if IS_STATUS_MONITOR_DIRECTIVE - if (wasRendering) { - wasRendering = false; - isRendering = true; - leventClear(&renderingStopEvent); - } - #endif - } + if (notification && notification->isActive()) { + notification->update(); + notification->draw(&renderer, promptOnly); + + // Only set flag if it's not already set + notificationCacheNeedsClearing.exchange(true, std::memory_order_acq_rel); + + } else if (notificationCacheNeedsClearing.exchange(false, std::memory_order_acq_rel)) { + tsl::gfx::FontManager::clearNotificationCache(); + #if IS_STATUS_MONITOR_DIRECTIVE + if (wasRendering) { + wasRendering = false; + isRendering = true; + leventClear(&renderingStopEvent); } + #endif } } @@ -11174,69 +11288,84 @@ namespace tsl { // Retrieve current focus and top/bottom elements of the GUI auto currentFocus = currentGui->getFocusedElement(); - auto topElement = currentGui->getTopElement(); - + const bool interpreterIsRunning = ult::runningInterpreter.load(std::memory_order_acquire); #if !IS_STATUS_MONITOR_DIRECTIVE if (interpreterIsRunning) { - if (keysDown & KEY_UP && !(keysHeld & ~KEY_UP & ALL_KEYS_MASK)) + if (keysDown & KEY_UP && !(keysHeld & ~KEY_UP & ALL_KEYS_MASK)) { currentFocus->shakeHighlight(FocusDirection::Up); - else if (keysDown & KEY_DOWN && !(keysHeld & ~KEY_DOWN & ALL_KEYS_MASK)) + return; + } + else if (keysDown & KEY_DOWN && !(keysHeld & ~KEY_DOWN & ALL_KEYS_MASK)) { currentFocus->shakeHighlight(FocusDirection::Down); - else if (keysDown & KEY_LEFT && !(keysHeld & ~KEY_LEFT & ALL_KEYS_MASK)) + return; + } + else if (keysDown & KEY_LEFT && !(keysHeld & ~KEY_LEFT & ALL_KEYS_MASK)) { currentFocus->shakeHighlight(FocusDirection::Left); - else if (keysDown & KEY_RIGHT && !(keysHeld & ~KEY_RIGHT & ALL_KEYS_MASK)) + return; + } + else if (keysDown & KEY_RIGHT && !(keysHeld & ~KEY_RIGHT & ALL_KEYS_MASK)) { currentFocus->shakeHighlight(FocusDirection::Right); + return; + } } #endif #if IS_STATUS_MONITOR_DIRECTIVE if (FullMode && !deactivateOriginalFooter) { - if (ult::simulatedSelect.load(std::memory_order_acquire)) { - ult::simulatedSelect.store(false, std::memory_order_release); + if (ult::simulatedSelect.exchange(false, std::memory_order_acq_rel)) keysDown |= KEY_A; - } - if (ult::simulatedBack.load(std::memory_order_acquire)) { - ult::simulatedBack.store(false, std::memory_order_release); + + if (ult::simulatedBack.exchange(false, std::memory_order_acq_rel)) keysDown |= KEY_B; - } if (!overrideBackButton) { if (keysDown & KEY_B && !(keysHeld & ~KEY_B & ALL_KEYS_MASK)) { if (!currentGui->handleInput(KEY_B,0,{},{},{})) { this->goBack(); + if (this->m_guiStack.size() >= 1) { + //triggerRumbleDoubleClick.store(true, std::memory_order_release); + //triggerExitSound.store(true, std::memory_order_release); + triggerExitFeedback(); + } //ult::simulatedBackComplete = true; } return; } } } else { - if (ult::simulatedSelect.load(std::memory_order_acquire)) - ult::simulatedSelect.store(false, std::memory_order_release); - if (ult::simulatedBack.load(std::memory_order_acquire)) - ult::simulatedBack.store(false, std::memory_order_release); + ult::simulatedSelect.exchange(false, std::memory_order_acq_rel); + ult::simulatedBack.exchange(false, std::memory_order_acq_rel); } #else - if (ult::simulatedSelect.load(std::memory_order_acquire)) { - ult::simulatedSelect.store(false, std::memory_order_release); + if (ult::simulatedSelect.exchange(false, std::memory_order_acq_rel)) keysDown |= KEY_A; - } - - if (ult::simulatedBack.load(std::memory_order_acquire)) { - ult::simulatedBack.store(false, std::memory_order_release); + + if (ult::simulatedBack.exchange(false, std::memory_order_acq_rel)) keysDown |= KEY_B; - //ult::simulatedBack = false; - } if (!overrideBackButton) { if (keysDown & KEY_B && !(keysHeld & ~KEY_B & ALL_KEYS_MASK)) { if (!currentGui->handleInput(KEY_B,0,{},{},{})) { this->goBack(); + if (this->m_guiStack.size() >= 1 && !interpreterIsRunning) { + //triggerRumbleDoubleClick.store(true, std::memory_order_release); + //triggerExitSound.store(true, std::memory_order_release); + triggerExitFeedback(); + } //ult::simulatedBackComplete = true; } return; } + } else { + if (keysDown & KEY_B && !(keysHeld & ~KEY_B & ALL_KEYS_MASK)) { + if (this->m_guiStack.size() >= 1 && !interpreterIsRunning) { + //triggerRumbleDoubleClick.store(true, std::memory_order_release); + //triggerExitSound.store(true, std::memory_order_release); + triggerExitFeedback(); + } + } } #endif @@ -11250,6 +11379,8 @@ namespace tsl { lastGuiPtr = currentGui.get(); // or just currentGui } + auto topElement = currentGui->getTopElement(); + const u64 currentTime_ns = armTicksToNs(armGetSystemTick()); if (!currentFocus && !ult::simulatedBack.load(std::memory_order_acquire) && !ult::stillTouching.load(std::memory_order_acquire) && !oldTouchDetected && !interpreterIsRunning) { @@ -11289,12 +11420,9 @@ namespace tsl { currentGui->removeFocus(); currentGui->requestFocus(topElement, FocusDirection::None); } - } - else if (ult::longTouchAndRelease.load(std::memory_order_acquire)) { - ult::longTouchAndRelease.store(false, std::memory_order_release); + } else if (ult::longTouchAndRelease.exchange(false, std::memory_order_acq_rel)) { hasScrolled = true; - } else if (ult::shortTouchAndRelease.load(std::memory_order_acquire)) { // cant be handled correctly without knowing where it is going after release - ult::shortTouchAndRelease.store(false, std::memory_order_release); + } else if (ult::shortTouchAndRelease.exchange(false, std::memory_order_acq_rel)) { hasScrolled = true; } } @@ -11997,6 +12125,8 @@ namespace tsl { * @note The Overlay gets closed once there are no more Guis on the stack */ void goBack(u32 count = 1) { + tsl::elm::g_disableMenuCacheOnReturn.store(true, std::memory_order_release); + // If there is exactly one GUI and an active notification, handle that first if (this->m_guiStack.size() == 1 && notification && notification->isActive()) { this->close(); @@ -12022,13 +12152,16 @@ namespace tsl { this->m_guiStack.pop(); } - if (tsl::elm::skipDeconstruction.load(std::memory_order_acquire)) - tsl::elm::skipDeconstruction.store(false, std::memory_order_release); - + tsl::elm::skipDeconstruction.exchange(false, std::memory_order_acq_rel); + // Close overlay if stack is empty if (this->m_guiStack.empty()) { this->close(); + } else { + //triggerRumbleDoubleClick.store(true, std::memory_order_release); + //triggerExitSound.store(true, std::memory_order_release); } + } void pop(u32 count = 1) { @@ -12251,6 +12384,8 @@ namespace tsl { // Clear any stale input from both controllers padUpdate(&pad_p1); padUpdate(&pad_handheld); + + //ult::initRumble(); // initialize rumble enum WaiterObject { WaiterObject_HomeButton, @@ -12271,16 +12406,16 @@ namespace tsl { auto lastTouchY = 0; // Preset touch boundaries - static constexpr int SWIPE_RIGHT_BOUND = 16; // 16 + 80 - static constexpr int SWIPE_LEFT_BOUND = (1280 - 16); - static constexpr u64 TOUCH_THRESHOLD_NS = 150'000'000ULL; // 150ms in nanoseconds - static constexpr u64 FAST_SWAP_THRESHOLD_NS = 150'000'000ULL; + constexpr int SWIPE_RIGHT_BOUND = 16; // 16 + 80 + constexpr int SWIPE_LEFT_BOUND = (1280 - 16); + constexpr u64 TOUCH_THRESHOLD_NS = 150'000'000ULL; // 150ms in nanoseconds + constexpr u64 FAST_SWAP_THRESHOLD_NS = 150'000'000ULL; // Global underscan monitoring - run at most once every 300ms - static auto lastUnderscanPixels = std::make_pair(0, 0); - static bool firstUnderscanCheck = true; - static u64 lastUnderscanCheckNs = 0; // store last execution in nanoseconds - static constexpr u64 UNDERSCAN_INTERVAL_NS = 300'000'000ULL; // 300ms in ns + auto lastUnderscanPixels = std::make_pair(0, 0); + bool firstUnderscanCheck = true; + u64 lastUnderscanCheckNs = 0; // store last execution in nanoseconds + constexpr u64 UNDERSCAN_INTERVAL_NS = 300'000'000ULL; // 300ms in ns s32 idx; Result rc; @@ -12294,25 +12429,29 @@ namespace tsl { ult::lastTitleID = ult::getTitleIdAsString(); //u64 elapsedTime_ns; + + // Notification variables + u64 lastNotifCheck = 0; + std::vector shownFiles; + std::string text; + int fontSize; + int priority; + time_t creationTime; + while (shData->running.load(std::memory_order_acquire)) { const u64 nowTick = armGetSystemTick(); const u64 nowNs = armTicksToNs(nowTick); - - + + // Scan for input changes from both controllers padUpdate(&pad_p1); padUpdate(&pad_handheld); // Read in HID values { - if (ult::launchingOverlay.load(std::memory_order_acquire)) - break; - std::scoped_lock lock(shData->dataMutex); - if (ult::launchingOverlay.load(std::memory_order_acquire)) - break; // Poll Title ID every 1 seconds if (!ult::resetForegroundCheck.load(std::memory_order_acquire)) { @@ -12335,7 +12474,7 @@ namespace tsl { if (resetElapsedNs >= 3'500'000'000ULL) { if (shData->overlayOpen && ult::currentForeground.load(std::memory_order_acquire)) { #if IS_STATUS_MONITOR_DIRECTIVE - if (!isMiniOrMicroMode) + if (!isValidOverlayMode()) hlp::requestForeground(true, false); #else hlp::requestForeground(true, false); @@ -12369,33 +12508,16 @@ namespace tsl { // Process notification files every 300ms { std::lock_guard jsonLock(notificationJsonMutex); - static u64 lastNotifCheck = 0; - + if (armTicksToNs(nowTick - lastNotifCheck) >= 300'000'000ULL) { lastNotifCheck = nowTick; - + DIR* dir = opendir(ult::NOTIFICATIONS_PATH.c_str()); if (dir) { if (ult::useNotifications) { - std::string filename, fullPath, prioStr; - - struct dirent* entry; - const std::string& notifPath = ult::NOTIFICATIONS_PATH; - static std::vector shownFiles; - - // Structure to hold file info with creation time - struct NotificationFile { - std::string filename; - std::string fullPath; - time_t creationTime; - int priority; - }; - - std::vector notificationFiles; - // --- Prune missing files from shownFiles --- for (auto it = shownFiles.begin(); it != shownFiles.end();) { const std::string fullPath = notifPath + *it; @@ -12406,40 +12528,49 @@ namespace tsl { } } - static std::string text; - static int fontSize; - static int priority; + // Reuse existing variables - track best file as we scan + static std::string bestFilename; + static std::string bestFullPath; + static time_t bestCreationTime; + static int bestPriority; - // --- Collect notification files with creation time --- + bestFilename.clear(); + bestFullPath.clear(); + bestPriority = -1; + bestCreationTime = 0; + bool foundAny = false; + + struct dirent* entry; + + // --- Find the best notification file in one pass --- while ((entry = readdir(dir)) != nullptr) { if (entry->d_type != DT_REG) continue; - filename = entry->d_name; - const size_t filenameLen = filename.size(); + const char* fname = entry->d_name; + const size_t filenameLen = strlen(fname); // Must end with ".notify" - if (filenameLen <= 7 || filename.compare(filenameLen - 7, 7, ".notify") != 0) + if (filenameLen <= 7 || strcmp(fname + filenameLen - 7, ".notify") != 0) continue; // Skip if already shown - if (std::find(shownFiles.begin(), shownFiles.end(), filename) != shownFiles.end()) + if (std::find(shownFiles.begin(), shownFiles.end(), fname) != shownFiles.end()) continue; // --- Build path --- - fullPath.clear(); + static std::string fullPath; fullPath = notifPath; - fullPath += filename; + fullPath += fname; // --- Get file creation/modification time --- struct stat fileStat; - time_t creationTime = 0; + creationTime = 0; if (stat(fullPath.c_str(), &fileStat) == 0) { - // Use modification time as creation time (more universally supported) creationTime = fileStat.st_mtime; } // --- Read priority from JSON --- - priority = 20; // default + priority = 20; // default (reuse existing variable) std::unique_ptr root( ult::readJsonFromFile(fullPath), ult::JsonDeleter()); if (root) { @@ -12450,32 +12581,30 @@ namespace tsl { } } - // Add to collection - notificationFiles.push_back({filename, fullPath, creationTime, priority}); + // --- Is this better than current best? --- + const bool isBetter = !foundAny || + (priority > bestPriority) || + (priority == bestPriority && creationTime < bestCreationTime); + + if (isBetter) { + bestFilename = fname; + bestFullPath = fullPath; + bestCreationTime = creationTime; + bestPriority = priority; + foundAny = true; + } } closedir(dir); - // --- Sort files by priority (higher first), then creation time (older first) --- - std::sort(notificationFiles.begin(), notificationFiles.end(), - [](const NotificationFile& a, const NotificationFile& b) { - // Primary sort: Higher priority first - if (a.priority != b.priority) { - return a.priority > b.priority; - } - // Secondary sort: Older creation time first (FIFO within same priority) - return a.creationTime < b.creationTime; - }); - - // --- Process files in chronological order --- - for (const auto& notifFile : notificationFiles) { - // --- Load JSON (safe outside notification lock) --- - text = ult::getStringFromJsonFile(notifFile.fullPath, "text"); + // --- Process the best file --- + if (foundAny) { + text = ult::getStringFromJsonFile(bestFullPath, "text"); if (!text.empty()) { - fontSize = 28; // default + fontSize = 28; // default (reuse existing variable) std::unique_ptr root( - ult::readJsonFromFile(notifFile.fullPath), ult::JsonDeleter()); + ult::readJsonFromFile(bestFullPath), ult::JsonDeleter()); if (root) { cJSON* croot = reinterpret_cast(root.get()); cJSON* fontSizeObj = cJSON_GetObjectItemCaseSensitive(croot, "font_size"); @@ -12486,18 +12615,18 @@ namespace tsl { // --- Show notification safely --- if (notification) { - notification->show(text, fontSize, notifFile.priority, notifFile.filename); + notification->show(text, fontSize, bestPriority, bestFilename); } // Mark file as shown - shownFiles.push_back(notifFile.filename); + shownFiles.push_back(bestFilename); } } } else { // --- Notifications disabled: delete all files --- struct dirent* entry; - std::string fullPath; + static std::string fullPath; while ((entry = readdir(dir)) != nullptr) { if (entry->d_type != DT_REG) continue; @@ -12520,13 +12649,87 @@ namespace tsl { } + if (ult::launchingOverlay.load(std::memory_order_acquire)) + break; + std::scoped_lock lock(shData->dataMutex); + if (ult::launchingOverlay.load(std::memory_order_acquire)) + break; + // Flush any pending rumble triggers when feedback is off + if (!ult::useHapticFeedback) { + triggerRumbleClick.exchange(false, std::memory_order_acq_rel); + triggerRumbleDoubleClick.exchange(false, std::memory_order_acq_rel); + } else { + ult::checkAndReinitRumble(); + + if (triggerRumbleDoubleClick.exchange(false)) { + if (!ult::doubleClickActive.load(std::memory_order_acquire)) { + ult::rumbleDoubleClick(); + } + triggerRumbleClick.exchange(false); + } else if (triggerRumbleClick.exchange(false)) { + ult::rumbleClick(); + } + + //const u64 _nowNs = armTicksToNs(armGetSystemTick()); + ult::processRumbleStop(nowNs); + ult::processRumbleDoubleClick(nowNs); + } + + // Flush any pending sound triggers when effects are off + + if (ult::expandedMemory) { + if (!ult::useSoundEffects || disableSound.load(std::memory_order_acquire)) { + triggerNavigationSound.exchange(false, std::memory_order_acq_rel); + triggerEnterSound.exchange(false, std::memory_order_acq_rel); + triggerExitSound.exchange(false, std::memory_order_acq_rel); + triggerWallSound.exchange(false, std::memory_order_acq_rel); + triggerOnSound.exchange(false, std::memory_order_acq_rel); + triggerOffSound.exchange(false, std::memory_order_acq_rel); + triggerSettingsSound.exchange(false, std::memory_order_acq_rel); + triggerMoveSound.exchange(false, std::memory_order_acq_rel); + } else { + if (reloadSoundCacheNow.exchange(false, std::memory_order_acq_rel)) { + ult::AudioPlayer::reloadAllSounds(); + } + + if (triggerNavigationSound.exchange(false)) { + ult::AudioPlayer::playNavigateSound(); + } else if (triggerEnterSound.exchange(false)) { + ult::AudioPlayer::playEnterSound(); + } else if (triggerExitSound.exchange(false)) { + ult::AudioPlayer::playExitSound(); + } else if (triggerWallSound.exchange(false)) { + ult::AudioPlayer::playWallSound(); + } else if (triggerOnSound.exchange(false)) { + ult::AudioPlayer::playOnSound(); + } else if (triggerOffSound.exchange(false)) { + ult::AudioPlayer::playOffSound(); + } else if (triggerSettingsSound.exchange(false)) { + ult::AudioPlayer::playSettingsSound(); + } else if (triggerMoveSound.exchange(false)) { + ult::AudioPlayer::playMoveSound(); + } + + //if (clearSoundCacheNow.exchange(false, std::memory_order_acq_rel)) { + // //ult::AudioPlayer::unloadAllSounds(ult::AudioPlayer::SoundType::Wall); + // ult::AudioPlayer::unloadAllSounds({ult::AudioPlayer::SoundType::Wall}); + // //ult::AudioPlayer::unloadAllSounds(); + // //clearSoundCacheNow.store(false, std::memory_order_release); + // clearSoundCacheNow.notify_all(); + //} + } + } + + //else if (triggerNavigationSound.exchange(false)) { + // ult::AudioPlayer::playSlideSound(); + //} // Combine inputs from both controllers const u64 kDown_p1 = padGetButtonsDown(&pad_p1); - const u64 kDown_handheld = padGetButtonsDown(&pad_handheld); const u64 kHeld_p1 = padGetButtons(&pad_p1); + const u64 kDown_handheld = padGetButtonsDown(&pad_handheld); const u64 kHeld_handheld = padGetButtons(&pad_handheld); shData->keysDown = kDown_p1 | kDown_handheld; @@ -12609,18 +12812,18 @@ namespace tsl { #if IS_STATUS_MONITOR_DIRECTIVE if (triggerExitNow) { - //ult::launchingOverlay.store(true, std::memory_order_release); + ult::launchingOverlay.store(true, std::memory_order_release); ult::setIniFileValue( ult::ULTRAHAND_CONFIG_INI_PATH, ult::ULTRAHAND_PROJECT_NAME, ult::IN_OVERLAY_STR, ult::FALSE_STR ); - //tsl::setNextOverlay( - // ult::OVERLAY_PATH + "ovlmenu.ovl" - //); - //tsl::Overlay::get()->close(); - tsl::goBack(); + tsl::setNextOverlay( + ult::OVERLAY_PATH + "ovlmenu.ovl" + ); + tsl::Overlay::get()->close(); + //tsl::goBack(); //triggerExitNow = false; break; } @@ -12763,7 +12966,7 @@ namespace tsl { eventClose(&captureButtonPressEvent); ult::launchingOverlay.store(true, std::memory_order_release); - tsl::setNextOverlay(ult::OVERLAY_PATH + "ovlmenu.ovl", "--direct"); + tsl::setNextOverlay(ult::OVERLAY_PATH + "ovlmenu.ovl", "--direct --comboReturn"); tsl::Overlay::get()->close(); eventFire(&shData->comboEvent); launchComboHasTriggered.store(true, std::memory_order_release); @@ -12776,7 +12979,7 @@ namespace tsl { finalArgs = modeArg; } else { // Only check overlay-specific launch args for non-ovlmenu entries - if (overlayFileName != "ovlmenu.ovl") { + if (overlayFileName.compare("ovlmenu.ovl") != 0) { // OPTIMIZED: Single INI read for both values auto overlaysIniData = ult::getParsedDataFromIniFile(ult::OVERLAYS_INI_FILEPATH); std::string useArgs = ""; @@ -12807,7 +13010,8 @@ namespace tsl { finalArgs += " --direct"; } - if (overlayFileName == "ovlmenu.ovl") { + if (overlayFileName.compare("ovlmenu.ovl") == 0) { + finalArgs += " --comboReturn"; ult::setIniFileValue( ult::ULTRAHAND_CONFIG_INI_PATH, ult::ULTRAHAND_PROJECT_NAME, @@ -12843,7 +13047,7 @@ namespace tsl { #if IS_STATUS_MONITOR_DIRECTIVE if (idx == WaiterObject_HomeButton || idx == WaiterObject_PowerButton) { // Changed condition to exclude capture button - if (shData->overlayOpen && !isMiniOrMicroMode) { + if (shData->overlayOpen && !isValidOverlayMode()) { tsl::Overlay::get()->hide(); shData->overlayOpen = false; } @@ -12888,7 +13092,8 @@ namespace tsl { } #if IS_STATUS_MONITOR_DIRECTIVE - if (isMiniOrMicroMode) { + bool inOverlayMode = isValidOverlayMode(); + if (inOverlayMode) { delayUpdate = true; isRendering = false; leventSignal(&renderingStopEvent); @@ -12901,7 +13106,7 @@ namespace tsl { ult::disableTransparency = false; #if IS_STATUS_MONITOR_DIRECTIVE - if (isMiniOrMicroMode) { + if (inOverlayMode) { isRendering = true; leventClear(&renderingStopEvent); delayUpdate = false; @@ -12961,6 +13166,8 @@ namespace tsl { static inline std::mutex setNextOverlayMutex; + + static inline std::string nextOverlayName; static void setNextOverlay(const std::string& ovlPath, std::string origArgs) { std::lock_guard lk(setNextOverlayMutex); char buffer[512]; @@ -12969,6 +13176,8 @@ namespace tsl { // Store filename and copy it const std::string filenameStr = ult::getNameFromPath(ovlPath); + nextOverlayName = filenameStr; + const char* filename = filenameStr.c_str(); while (*filename && p < bufferEnd) *p++ = *filename++; if (p < bufferEnd) *p++ = ' '; @@ -13007,12 +13216,6 @@ namespace tsl { while (src < end && *src == ' ') src++; // Skip spaces while (src < end && *src != ' ' && *src != '\0') src++; // Skip title ID } - //else if (strncmp(src, "--promptDuration", 16) == 0) { - // // skip any existing --promptDuration (we’ll re-add it) - // src += 16; - // while (src < end && *src == ' ') src++; - // while (src < end && *src != ' ' && *src != '\0') src++; - //} else { // Copy unknown flag while (src < end && *src != ' ' && p < bufferEnd) *p++ = *src++; @@ -13046,18 +13249,6 @@ namespace tsl { const char* titleId = ult::lastTitleID.c_str(); while (*titleId && p < bufferEnd) *p++ = *titleId++; } - - // Add prompt duration - //{ - // const s64 duration = notification->remainingTime(); // nanoseconds left - // if (duration > 0) { - // const std::string promptArg = " --promptDuration " + std::to_string(duration); - // if ((p + promptArg.size()) < bufferEnd) { - // memcpy(p, promptArg.c_str(), promptArg.size()); - // p += promptArg.size(); - // } - // } - //} // Safety check - if we're at the end, we might have truncated if (p >= bufferEnd) { @@ -13083,7 +13274,9 @@ namespace tsl { {"skipCombo", 9, 2}, {"lastTitleID", 11, 3}, {"foregroundFix", 13, 4}, - {"package", 7, 5} + {"package", 7, 5}, + {"lastSelectedItem", 16, 6}, + {"comboReturn", 11, 7} // new option }; @@ -13101,7 +13294,9 @@ namespace tsl { static inline int loop(int argc, char** argv) { static_assert(std::is_base_of_v, "tsl::loop expects a type derived from tsl::Overlay"); - + #if IS_STATUS_MONITOR_DIRECTIVE + leventClear(&renderingStopEvent); + #endif // Initialize buffer sizes based on expanded memory setting if (ult::expandedMemory) { @@ -13109,7 +13304,7 @@ namespace tsl { ult::HEX_BUFFER_SIZE = 8192; ult::UNZIP_READ_BUFFER = 262144; ult::UNZIP_WRITE_BUFFER = 131072; - ult::DOWNLOAD_READ_BUFFER = 262144; + ult::DOWNLOAD_READ_BUFFER = 262144/2; ult::DOWNLOAD_WRITE_BUFFER = 131072; } @@ -13121,19 +13316,7 @@ namespace tsl { bool skip; for (u8 arg = 1; arg < argc; arg++) { const char* s = argv[arg]; - #if IS_STATUS_MONITOR_DIRECTIVE - if (s[0] == '-') { - if (s[1] == 'm') { - if (strcasecmp(s, "-mini") == 0 || strcasecmp(s, "-micro") == 0) { - isMiniOrMicroMode = true; - } - } else if (s[1] == '-' && s[2] == 'm') { - if (strcasecmp(s, "--miniOverlay") == 0 || strcasecmp(s, "--microOverlay") == 0) { - isMiniOrMicroMode = true; - } - } - } - #endif + skip = false; if (arg > 1) { @@ -13178,18 +13361,20 @@ namespace tsl { bool skipCombo = false; #if IS_LAUNCHER_DIRECTIVE + bool comboReturn = false; bool directMode = true; #else bool directMode = false; #endif bool usingPackageLauncher = false; + for (u8 arg = 0; arg < argc; arg++) { const char* s = argv[arg]; if (s[0] != '-' || s[1] != '-') continue; const char* opt = s + 2; - for (u8 i = 0; i < 5; i++) { + for (u8 i = 0; i < 7; i++) { // now 6 instead of 5 if (memcmp(opt, options[i].name, options[i].len) == 0 && opt[options[i].len] == '\0') { switch (options[i].action) { case 1: // direct @@ -13213,13 +13398,24 @@ namespace tsl { break; case 4: // foregroundFix if (++arg < argc) { - ult::resetForegroundCheck.store(ult::resetForegroundCheck.load(std::memory_order_acquire) || - (argv[arg][0] == '1'), std::memory_order_release); + ult::resetForegroundCheck.store( + ult::resetForegroundCheck.load(std::memory_order_acquire) || + (argv[arg][0] == '1'), std::memory_order_release); } break; case 5: // package usingPackageLauncher = true; break; + case 6: // lastSelectedItem + #if IS_STATUS_MONITOR_DIRECTIVE + lastMode = "returning"; + #endif + break; + case 7: // comboReturn + #if IS_LAUNCHER_DIRECTIVE + comboReturn = true; + #endif + break; } } } @@ -13244,13 +13440,25 @@ namespace tsl { #if !IS_LAUNCHER_DIRECTIVE tsl::initializeUltrahandSettings(); #endif + + // Initialize the audio service + if (ult::useSoundEffects && ult::expandedMemory) { + ult::AudioPlayer::initialize(); + } + + + overlay->initScreen(); overlay->changeTo(overlay->loadInitialGui()); - + + + bool shouldFireEvent = false; + #if IS_LAUNCHER_DIRECTIVE + { bool inOverlay; - bool shouldFireEvent = false; + auto configData = ult::getParsedDataFromIniFile(ult::ULTRAHAND_CONFIG_INI_PATH); bool needsUpdate = false; @@ -13282,8 +13490,25 @@ namespace tsl { } } #else + { + + auto configData = ult::getParsedDataFromIniFile(ult::ULTRAHAND_CONFIG_INI_PATH); + + auto projectIt = configData.find(ult::ULTRAHAND_PROJECT_NAME); + if (projectIt != configData.end()) { + auto overlayIt = projectIt->second.find(ult::IN_OVERLAY_STR); + const bool inOverlay = (overlayIt == projectIt->second.end() || overlayIt->second != ult::FALSE_STR); + + if (inOverlay && directMode) { + configData[ult::ULTRAHAND_PROJECT_NAME][ult::IN_OVERLAY_STR] = ult::FALSE_STR; + ult::saveIniFileData(ult::ULTRAHAND_CONFIG_INI_PATH, configData); + } + } + } + if (skipCombo) { eventFire(&shData.comboEvent); + shouldFireEvent = true; } #endif @@ -13329,8 +13554,7 @@ namespace tsl { overlay->loop(true); // Draw prompts while hidden } - if (mainComboHasTriggered.load(std::memory_order_acquire)) { - mainComboHasTriggered.store(false, std::memory_order_acquire); + if (mainComboHasTriggered.exchange(false, std::memory_order_acq_rel)) { comboBreakout = true; exitAfterPrompt = false; break; @@ -13361,11 +13585,12 @@ namespace tsl { shData.running.store(false, std::memory_order_release); shData.overlayOpen.store(false, std::memory_order_release); ult::launchingOverlay.store(true, std::memory_order_release); + launchComboHasTriggered.store(true, std::memory_order_release); // for isolating sound effect if (usingPackageLauncher || directMode) { tsl::setNextOverlay(ult::OVERLAY_PATH + "ovlmenu.ovl"); } - + hlp::requestForeground(false); break; } @@ -13384,7 +13609,7 @@ namespace tsl { shData.overlayOpen.store(true, std::memory_order_release); #if IS_STATUS_MONITOR_DIRECTIVE - if (!isMiniOrMicroMode) + if (!isValidOverlayMode()) hlp::requestForeground(true); #else hlp::requestForeground(true); @@ -13393,8 +13618,17 @@ namespace tsl { overlay->show(); if (!comboBreakout && !(notification && notification->isActive())) overlay->clearScreen(); + + { + std::scoped_lock lock(shData.dataMutex); + // Clear derived states that the overlay loop will use + shData.keysDown = 0; + shData.keysHeld = 0; + // Clear any queued pending keys so nothing gets processed one frame late + shData.keysDownPending = 0; + } } - + while (shData.running.load(std::memory_order_acquire)) { { @@ -13411,6 +13645,37 @@ namespace tsl { } shData.keysDownPending = 0; } + #if IS_LAUNCHER_DIRECTIVE + if (shouldFireEvent) { + shouldFireEvent = false; + + if (!comboReturn) { + //triggerRumbleDoubleClick.store(true, std::memory_order_release); + //triggerExitSound.store(true, std::memory_order_release); + triggerExitFeedback(); + //} else { + // triggerRumbleClick.store(true, std::memory_order_release); + } + } + #else + if (!directMode && shouldFireEvent) { + shouldFireEvent = false; + #if IS_STATUS_MONITOR_DIRECTIVE + if (lastMode.compare("returning") == 0) { + //triggerRumbleDoubleClick.store(true, std::memory_order_release); + //triggerExitSound.store(true, std::memory_order_release); + triggerExitFeedback(); + } else { + //triggerRumbleClick.store(true, std::memory_order_release); + triggerEnterSound.store(true, std::memory_order_release); + } + #else + //triggerRumbleClick.store(true, std::memory_order_release); + //triggerEnterSound.store(true, std::memory_order_release); + triggerEnterFeedback(); + #endif + } + #endif } #if IS_STATUS_MONITOR_DIRECTIVE @@ -13443,6 +13708,7 @@ namespace tsl { //std::scoped_lock lock(shData.dataMutex); shData.running.store(false, std::memory_order_release); shData.overlayOpen.store(false, std::memory_order_release); + break; } } @@ -13459,20 +13725,13 @@ namespace tsl { eventClear(&shData.comboEvent); } } - //if (notification) - // notification->forceShutdown(); - - //while (notification && notification->isActive()) { - // notification->update(true, true); // No file ops, allow state transitions - // svcSleepThread(10'000'000); // 1ms sleep - //} - //tsl::notificationGeneration.fetch_add(1, std::memory_order_release); // Ensure background thread is fully stopped before overlay cleanup shData.running.store(false, std::memory_order_release); threadWaitForExit(&backgroundThread); threadClose(&backgroundThread); + // Cleanup overlay resources tsl::elm::fullDeconstruction.store(true, std::memory_order_release); hlp::requestForeground(false); @@ -13480,22 +13739,18 @@ namespace tsl { overlay->exitServices(); delete overlay; - // Synchronize notification shutdown - //if (notification) { - // notification->forceShutdown(); // Immediate disable of new notifications - // while (notification->isActive()) { - // notification->update(true, true); // No file ops, allow state transitions - // svcSleepThread(1'000'000); // 1ms sleep - // } - // - // notificationGeneration.fetch_add(1, std::memory_order_release); - // delete notification; - // - // //lock.unlock(); - //} - eventClose(&shData.comboEvent); + + + if (directMode && !launchComboHasTriggered.load(std::memory_order_acquire)) { + if (!disableSound.load(std::memory_order_acquire) && ult::useSoundEffects) + ult::AudioPlayer::playExitSound(); + if (ult::useHapticFeedback) { + ult::rumbleDoubleClickStandalone(); + } + } + // Brief delay to ensure thread quiescence before nx-ovlloader transition //svcSleepThread(100'000'000); // 100ms @@ -13507,8 +13762,6 @@ namespace tsl { } - - #ifdef TESLA_INIT_IMPL namespace tsl::cfg { @@ -13536,38 +13789,44 @@ extern "C" { * */ void __appInit(void) { - tsl::hlp::doWithSmSession([]{ - - ASSERT_FATAL(fsInitialize()); - ASSERT_FATAL(hidInitialize()); // Controller inputs and Touch - if (hosversionAtLeast(16,0,0)) { - ASSERT_FATAL(plInitialize(PlServiceType_User)); // Font data. Use pl:u for 16.0.0+ - } else { - ASSERT_FATAL(plInitialize(PlServiceType_System)); // Use pl:s for 15.0.1 and below to prevent qlaunch/overlaydisp session exhaustion - } - ASSERT_FATAL(pmdmntInitialize()); // PID querying - ASSERT_FATAL(hidsysInitialize()); // Focus control - ASSERT_FATAL(setsysInitialize()); // Settings querying - - // Time initializations - ASSERT_FATAL(timeInitialize()); // CUSTOM MODIFICATION - __libnx_init_time(); // CUSTOM MODIFICATION - timeExit(); // CUSTOM MODIFICATION - - #if USING_WIDGET_DIRECTIVE - ult::powerInit(); - i2cInitialize(); - #endif - - fsdevMountSdmc(); - splInitialize(); - spsmInitialize(); - //i2cInitialize(); - //ASSERT_FATAL(socketInitializeDefault()); - //ASSERT_FATAL(nifmInitialize(NifmServiceType_User)); - }); ASSERT_FATAL(smInitialize()); // needed to prevent issues with powering device into sleep + //tsl::hlp::doWithSmSession([]{ + + ASSERT_FATAL(fsInitialize()); + ASSERT_FATAL(hidInitialize()); // Controller inputs and Touch + if (hosversionAtLeast(16,0,0)) { + ASSERT_FATAL(plInitialize(PlServiceType_User)); // Font data. Use pl:u for 16.0.0+ + } else { + ASSERT_FATAL(plInitialize(PlServiceType_System)); // Use pl:s for 15.0.1 and below to prevent qlaunch/overlaydisp session exhaustion + } + ASSERT_FATAL(pmdmntInitialize()); // PID querying + ASSERT_FATAL(hidsysInitialize()); // Focus control + ASSERT_FATAL(setsysInitialize()); // Settings querying + + // Time initializations + if R_SUCCEEDED(timeInitialize()) { + __libnx_init_time(); + timeExit(); + } + + #if USING_WIDGET_DIRECTIVE + ult::powerInit(); + i2cInitialize(); + #endif + + fsdevMountSdmc(); + splInitialize(); + spsmInitialize(); + //i2cInitialize(); + //ASSERT_FATAL(socketInitializeDefault()); + //ASSERT_FATAL(nifmInitialize(NifmServiceType_User)); + + //}); + + + + #if IS_STATUS_MONITOR_DIRECTIVE Service *plSrv = plGetServiceSession(); Service plClone; @@ -13589,7 +13848,11 @@ extern "C" { delete tsl::notification; eventClose(&tsl::notificationEvent); - smExit(); + //deinitRumble(); + if (ult::expandedMemory) + ult::AudioPlayer::exit(); + + //socketExit(); //nifmExit(); spsmExit(); @@ -13607,6 +13870,7 @@ extern "C" { pmdmntExit(); hidsysExit(); setsysExit(); + smExit(); // Final cleanup tsl::gfx::FontManager::cleanup(); @@ -13614,4 +13878,4 @@ extern "C" { } -#endif \ No newline at end of file +#endif diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/audio_player.hpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/audio_player.hpp new file mode 100644 index 00000000..d9e9765e --- /dev/null +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/audio_player.hpp @@ -0,0 +1,96 @@ +/******************************************************************************** + * File: audio_player.hpp + * Author: ppkantorski + * Description: + * This header defines the AudioPlayer class and related structures used for + * handling sound playback within the Ultrahand Overlay. It provides interfaces + * for loading, caching, and playing WAV audio through libnx’s audout service, + * along with basic sound type management and synchronization support. + * + * For the latest updates and contributions, visit the project's GitHub repository. + * (GitHub Repository: https://github.com/ppkantorski/Ultrahand-Overlay) + * + * Note: Please be aware that this notice cannot be altered or removed. It is a part + * of the project's documentation and must remain intact. + * + * Licensed under both GPLv2 and CC-BY-4.0 + * Copyright (c) 2025 ppkantorski + ********************************************************************************/ + +#pragma once +#include +#include +#include +#include +#include +#include +#include + +namespace ult { + class AudioPlayer { + public: + enum class SoundType : uint8_t { // <- uint8_t saves space + Navigate, + Enter, + Exit, + Wall, + On, + Off, + Settings, + Move, + Count + }; + + struct CachedSound { + void* buffer = nullptr; + uint32_t bufferSize = 0; + uint32_t dataSize = 0; + }; + + static bool initialize(); + static void exit(); + static void playSound(SoundType type); + + // Inline wrappers - same API, zero overhead + static inline void playNavigateSound() { playSound(SoundType::Navigate); } + static inline void playEnterSound() { playSound(SoundType::Enter); } + static inline void playExitSound() { playSound(SoundType::Exit); } + static inline void playWallSound() { playSound(SoundType::Wall); } + static inline void playOnSound() { playSound(SoundType::On); } + static inline void playOffSound() { playSound(SoundType::Off); } + static inline void playSettingsSound() { playSound(SoundType::Settings); } + static inline void playMoveSound() { playSound(SoundType::Move); } + + static void setMasterVolume(float volume); + static void setEnabled(bool enabled); + static bool isEnabled(); + static bool isDocked(); + static bool reloadIfDockedChanged(); + static void reloadAllSounds(); + static void unloadAllSounds(const std::initializer_list& excludeSounds = {}); + static std::mutex m_audioMutex; + + private: + static bool m_initialized; + static std::atomic m_enabled; // <- atomic for lock-free reads + static float m_masterVolume; + static std::vector m_cachedSounds; + + static bool m_lastDockedState; + + inline static constexpr const char* m_soundPaths[static_cast(SoundType::Count)] = { + "sdmc:/config/ultrahand/sounds/tick.wav", + "sdmc:/config/ultrahand/sounds/enter.wav", + "sdmc:/config/ultrahand/sounds/exit.wav", + "sdmc:/config/ultrahand/sounds/wall.wav", + "sdmc:/config/ultrahand/sounds/on.wav", + "sdmc:/config/ultrahand/sounds/off.wav", + "sdmc:/config/ultrahand/sounds/settings.wav", + "sdmc:/config/ultrahand/sounds/move.wav" + }; + + //static void playAudioBuffer(void* buffer, uint32_t bufferSize); + static bool loadSoundFromWav(SoundType type, const char* path); + + }; +} \ No newline at end of file diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/debug_funcs.hpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/debug_funcs.hpp index ea8acba5..aa0a045d 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/debug_funcs.hpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/debug_funcs.hpp @@ -45,6 +45,7 @@ namespace ult { * * @param message The message to be logged. */ + void logMessage(const char* message); void logMessage(const std::string& message); #endif } diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/download_funcs.hpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/download_funcs.hpp index b0d0958c..240db66c 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/download_funcs.hpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/download_funcs.hpp @@ -15,6 +15,7 @@ * Licensed under both GPLv2 and CC-BY-4.0 * Copyright (c) 2024 ppkantorski ********************************************************************************/ + #pragma once #ifndef DOWNLOAD_FUNCS_HPP #define DOWNLOAD_FUNCS_HPP @@ -59,27 +60,20 @@ namespace ult { extern std::atomic downloadPercentage; extern std::atomic unzipPercentage; - // User agent string for curl requests - inline constexpr const char* userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"; - - // Custom deleters for CURL handles - struct CurlDeleter { - void operator()(CURL* curl) const; - }; // Thread-safe callback functions - #if !USING_FSTREAM_DIRECTIVE - size_t writeCallback(void* ptr, size_t size, size_t nmemb, FILE* stream); - #else - size_t writeCallback(void* ptr, size_t size, size_t nmemb, std::ostream* stream); - #endif + //#if !USING_FSTREAM_DIRECTIVE + //size_t writeCallback(void* ptr, size_t size, size_t nmemb, FILE* stream); + //#else + //size_t writeCallback(void* ptr, size_t size, size_t nmemb, std::ostream* stream); + //#endif - int progressCallback(void* ptr, curl_off_t totalToDownload, curl_off_t nowDownloaded, curl_off_t totalToUpload, curl_off_t nowUploaded); + //int progressCallback(void* ptr, curl_off_t totalToDownload, curl_off_t nowDownloaded, curl_off_t totalToUpload, curl_off_t nowUploaded); // Thread-safe initialization and cleanup functions - void initializeCurl(); - void cleanupCurl(); + //void initializeCurl(); + //void cleanupCurl(); // Main API functions - thread-safe and optimized bool downloadFile(const std::string& url, const std::string& toDestination, bool noPercentagePolling=false); diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/global_vars.hpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/global_vars.hpp index f4e226bc..26ea2aef 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/global_vars.hpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/global_vars.hpp @@ -44,6 +44,7 @@ namespace ult { extern const std::string LANG_PATH; extern const std::string THEMES_PATH; extern const std::string WALLPAPERS_PATH; + extern const std::string SOUNDS_PATH; extern const std::string FLAGS_PATH; extern const std::string NOTIFICATIONS_PATH; extern const std::string PAYLOADS_PATH; @@ -81,6 +82,7 @@ namespace ult { extern const std::string OLD_NX_OVLLOADER_ZIP_URL; extern const std::string OLD_NX_OVLLOADER_PLUS_ZIP_URL; extern const std::string UPDATER_PAYLOAD_URL; + extern const std::string SOUND_EFFECTS_URL; extern const std::string LAUNCH_ARGS_STR; extern const std::string USE_LAUNCH_ARGS_STR; diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/haptics.hpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/haptics.hpp new file mode 100644 index 00000000..1b887295 --- /dev/null +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/haptics.hpp @@ -0,0 +1,41 @@ +/******************************************************************************** + * File: haptics.hpp + * Author: ppkantorski + * Description: + * This header declares functions and shared flags for managing haptic feedback + * in the Ultrahand Overlay. It includes routines for initializing vibration + * devices, sending rumble and double-click patterns, and controlling timing + * for single and double pulse haptics. Atomic flags ensure safe access across + * threads. + * + * For the latest updates and contributions, visit the project's GitHub repository. + * (GitHub Repository: https://github.com/ppkantorski/Ultrahand-Overlay) + * + * Note: Please be aware that this notice cannot be altered or removed. It is a part + * of the project's documentation and must remain intact. + * + * Licensed under both GPLv2 and CC-BY-4.0 + * Copyright (c) 2025 ppkantorski + ********************************************************************************/ + +#pragma once +#include +#include +#include + +namespace ult { + + //extern bool rumbleInitialized; + extern std::atomic rumbleActive; + extern std::atomic doubleClickActive; + + //void initRumble(); + void deinitRumble(); + void checkAndReinitRumble(); + + void rumbleClick(); + void rumbleDoubleClick(); + void processRumbleStop(u64 nowNs); + void processRumbleDoubleClick(u64 nowNs); + void rumbleDoubleClickStandalone(); +} \ No newline at end of file diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/json_funcs.hpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/json_funcs.hpp index 40b43488..5995cc7d 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/json_funcs.hpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/json_funcs.hpp @@ -102,6 +102,6 @@ namespace ult { bool renameJsonKey(const std::string& filePath, const std::string& oldKey, const std::string& newKey); - void pushNotificationJson(const std::string& text, size_t fontSize=28); + void pushNotificationJson(const std::string& appID, const std::string& text, size_t fontSize=28); } #endif \ No newline at end of file diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/list_funcs.hpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/list_funcs.hpp index baa347dd..b1b8aabb 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/list_funcs.hpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/list_funcs.hpp @@ -101,7 +101,7 @@ namespace ult { // Helper function to read a text file and process each line with a callback - void processFileLines(const std::string& filePath, const std::function& callback); + //void processFileLines(const std::string& filePath, const std::function& callback); void compareWildcardFilesLists(const std::string& wildcardPatternFilePath, const std::string& txtFilePath, const std::string& outputTxtFilePath); diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/mod_funcs.hpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/mod_funcs.hpp index fcbcc51d..b5b04315 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/mod_funcs.hpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/mod_funcs.hpp @@ -41,9 +41,9 @@ namespace ult { inline constexpr const char* IPS32_FOOT_MAGIC = "EEOF"; //const std::string CHEAT_HEADER = "// auto generated by pchtxt2cheat\n\n"; - extern const std::string CHEAT_TYPE; - extern const std::string CHEAT_EXT; - extern const std::string CHEAT_ENCODING; + //extern const std::string CHEAT_TYPE; + //extern const std::string CHEAT_EXT; + //extern const std::string CHEAT_ENCODING; /** * @brief Checks if a cheat already exists in the cheat file. @@ -83,13 +83,26 @@ namespace ult { bool pchtxt2cheat(const std::string &pchtxtPath, std::string cheatName = "", std::string outCheatPath = ""); // Corrected helper function to convert values to big-endian format - uint32_t toBigEndian(uint32_t value); + //uint32_t toBigEndian(uint32_t value); + // + //uint16_t toBigEndian(uint16_t value); + + // Corrected helper function to convert values to big-endian format + inline uint32_t toBigEndian(uint32_t value) { + return ((value & 0x000000FF) << 24) | + ((value & 0x0000FF00) << 8) | + ((value & 0x00FF0000) >> 8) | + ((value & 0xFF000000) >> 24); + } - uint16_t toBigEndian(uint16_t value); + inline uint16_t toBigEndian(uint16_t value) { + return ((value & 0x00FF) << 8) | + ((value & 0xFF00) >> 8); + } // Helper function to convert a vector of bytes to a hex string for logging - std::string hexToString(const std::vector& bytes); + //std::string hexToString(const std::vector& bytes); /** diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/string_funcs.hpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/string_funcs.hpp index 607859bd..71696d07 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/string_funcs.hpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/string_funcs.hpp @@ -40,6 +40,7 @@ namespace ult { extern int stoi(const std::string& str, std::size_t* pos = nullptr, int base = 10); extern float stof(const std::string& str); + extern bool canConvertToInt(const std::string& str); /** * @brief A lightweight string stream class that mimics basic functionality of std::istringstream. diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/tsl_utils.hpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/tsl_utils.hpp index ea65a334..4baabffe 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/tsl_utils.hpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/tsl_utils.hpp @@ -125,6 +125,8 @@ namespace ult { bool consoleIsDocked(); + std::string getBuildIdAsString(); + std::string getTitleIdAsString(); extern std::string lastTitleID; @@ -138,6 +140,8 @@ namespace ult { extern bool useSwipeToOpen; extern bool useLaunchCombos; extern bool useNotifications; + extern bool useSoundEffects; + extern bool useHapticFeedback; extern bool usePageSwap; extern std::atomic noClickableItems; @@ -306,6 +310,7 @@ namespace ult { extern const std::string whiteColor; extern const std::string blackColor; + extern const std::string greyColor; extern std::atomic languageWasChanged; @@ -405,6 +410,8 @@ namespace ult { extern std::string LAUNCH_COMBOS; extern std::string NOTIFICATIONS; + extern std::string SOUND_EFFECTS; + extern std::string HAPTIC_FEEDBACK; extern std::string OPAQUE_SCREENSHOTS; extern std::string PACKAGE_INFO; @@ -563,7 +570,7 @@ namespace ult { float calculateAmplitude(float x, float peakDurationFactor = 0.25f); - + extern std::atomic refreshWallpaperNow; extern std::atomic refreshWallpaper; extern std::vector wallpaperData; extern std::atomic inPlot; diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/ultra.hpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/ultra.hpp index 7333c6a3..c0d1f1f8 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/include/ultra.hpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/include/ultra.hpp @@ -43,5 +43,7 @@ #include "download_funcs.hpp" #include "mod_funcs.hpp" #include "tsl_utils.hpp" +#include "audio_player.hpp" +#include "haptics.hpp" #endif // ULTRA_HPP \ No newline at end of file diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/audio_player.cpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/audio_player.cpp new file mode 100644 index 00000000..b9246519 --- /dev/null +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/audio_player.cpp @@ -0,0 +1,312 @@ +/******************************************************************************** + * File: audio_player.cpp + * Author: ppkantorski + * Description: + * Memory-optimized version with reduced allocation overhead and chunked I/O. + * Key changes: + * - Eliminated temporary vector allocations (saves 50% memory during load) + * - Chunked file reading to reduce peak memory usage + * - Reduced alignment padding (saves ~3-4KB per sound) + * - Added lazy loading option via unloadAllSounds() + * + * For the latest updates and contributions, visit the project's GitHub repository. + * (GitHub Repository: https://github.com/ppkantorski/Ultrahand-Overlay) + * + * Note: Please be aware that this notice cannot be altered or removed. It is a part + * of the project's documentation and must remain intact. + * + * Licensed under both GPLv2 and CC-BY-4.0 + * Copyright (c) 2025 ppkantorski + ********************************************************************************/ + +#include "audio_player.hpp" + +namespace ult { + bool AudioPlayer::m_initialized = false; + std::atomic AudioPlayer::m_enabled{true}; + float AudioPlayer::m_masterVolume = 0.6f; + bool AudioPlayer::m_lastDockedState = false; + std::vector AudioPlayer::m_cachedSounds; + std::mutex AudioPlayer::m_audioMutex; + + bool AudioPlayer::initialize() { + std::lock_guard lock(m_audioMutex); + + if (m_initialized) return true; + + if (R_FAILED(audoutInitialize()) || R_FAILED(audoutStartAudioOut())) { + audoutExit(); + return false; + } + + m_initialized = true; + m_cachedSounds.resize(static_cast(SoundType::Count)); + m_lastDockedState = isDocked(); + reloadAllSounds(); + + return true; + } + + void AudioPlayer::exit() { + std::lock_guard lock(m_audioMutex); + + // Free all cached sound buffers + for (auto& cached : m_cachedSounds) { + if (cached.buffer) { + free(cached.buffer); + cached.buffer = nullptr; + } + cached.bufferSize = 0; + cached.dataSize = 0; + } + + if (m_initialized) { + audoutStopAudioOut(); + audoutExit(); + m_initialized = false; + } + } + + void AudioPlayer::reloadAllSounds() { + for (uint32_t i = 0; i < static_cast(SoundType::Count); ++i) { + loadSoundFromWav(static_cast(i), m_soundPaths[i]); + } + } + + void AudioPlayer::unloadAllSounds(const std::initializer_list& excludeSounds) { + std::lock_guard lock(m_audioMutex); + if (!m_initialized) return; + + for (uint32_t i = 0; i < m_cachedSounds.size(); ++i) { + SoundType current = static_cast(i); + + // Skip if this sound is in the exclude list + if (std::find(excludeSounds.begin(), excludeSounds.end(), current) != excludeSounds.end()) { + continue; + } + + auto& cached = m_cachedSounds[i]; + if (cached.buffer) { + free(cached.buffer); + cached.buffer = nullptr; + } + cached.bufferSize = 0; + cached.dataSize = 0; + } + } + + bool AudioPlayer::reloadIfDockedChanged() { + if (!m_initialized) return false; + + const bool currentDocked = isDocked(); + if (currentDocked == m_lastDockedState) return false; + + std::lock_guard lock(m_audioMutex); + m_lastDockedState = currentDocked; + reloadAllSounds(); + + return true; + } + + bool AudioPlayer::loadSoundFromWav(SoundType type, const char* path) { + const uint32_t idx = static_cast(type); + if (!m_initialized || idx >= static_cast(SoundType::Count)) return false; + + // Free existing buffer + free(m_cachedSounds[idx].buffer); + m_cachedSounds[idx] = { nullptr, 0, 0 }; + + FILE* f = fopen(path, "rb"); + if (!f) return false; + + // Parse WAV header + char hdr[12]; + if (fread(hdr, 1, 12, f) != 12 || memcmp(hdr, "RIFF", 4) || memcmp(hdr + 8, "WAVE", 4)) { + fclose(f); + return false; + } + + u16 fmt = 0, ch = 0, bits = 0; + u32 rate = 0, dSize = 0; + long dPos = 0; + + // Find fmt and data chunks + while (fread(hdr, 1, 8, f) == 8) { + const u32 sz = *(u32*)(hdr + 4); + if (!memcmp(hdr, "fmt ", 4)) { + fread(&fmt, 2, 1, f); + fread(&ch, 2, 1, f); + fread(&rate, 4, 1, f); + fseek(f, 6, SEEK_CUR); + fread(&bits, 2, 1, f); + fseek(f, sz - 16, SEEK_CUR); + } else if (!memcmp(hdr, "data", 4)) { + dSize = sz; + dPos = ftell(f); + break; + } else { + fseek(f, sz, SEEK_CUR); + } + } + + // Validate format + if (!dSize || fmt != 1 || ch == 0 || ch > 2 || (bits != 8 && bits != 16)) { + fclose(f); + return false; + } + + // Calculate buffer sizes + // Note: audout REQUIRES stereo (2 channels), so we must duplicate mono + const bool mono = (ch == 1); + const uint32_t inSamples = dSize / (bits / 8); + const uint32_t outSamples = mono ? inSamples * 2 : inSamples; // Duplicate mono to stereo + const uint32_t outSize = outSamples * 2; // 16-bit samples + + // Use smaller alignment to reduce waste (256 bytes instead of 4KB) + const uint32_t align = 0x100; + const uint32_t bufSize = (outSize + align - 1) & ~(align - 1); + + // Allocate output buffer + void* buf = aligned_alloc(align, bufSize); + if (!buf) { + fclose(f); + return false; + } + + fseek(f, dPos, SEEK_SET); + s16* out = (s16*)buf; + + // Calculate volume scaling + float effectiveVolume = m_masterVolume; + if (m_lastDockedState) { + effectiveVolume *= 0.5f; + } + const float scale = std::clamp(effectiveVolume, 0.0f, 1.0f); + + // Process audio in chunks to minimize memory usage + // This eliminates the need for temporary vectors + constexpr uint32_t CHUNK_SIZE = 512; + + if (bits == 8) { + // 8-bit audio: read and convert in chunks + const int32_t scaleInt = static_cast(scale * 256.0f); + u8 chunk[CHUNK_SIZE]; + uint32_t remaining = inSamples; + uint32_t outIdx = 0; + + while (remaining > 0) { + const uint32_t toRead = std::min(remaining, CHUNK_SIZE); + if (fread(chunk, 1, toRead, f) != toRead) { + free(buf); + fclose(f); + return false; + } + + for (uint32_t i = 0; i < toRead; ++i) { + const s16 sample = static_cast((chunk[i] - 128) * scaleInt); + if (mono) { + // Duplicate to both L and R channels for stereo output + out[outIdx++] = sample; // Left + out[outIdx++] = sample; // Right + } else { + out[outIdx++] = sample; + } + } + remaining -= toRead; + } + } else { + // 16-bit audio: read and convert in chunks + s16 chunk[CHUNK_SIZE]; + uint32_t remaining = inSamples; + uint32_t outIdx = 0; + + while (remaining > 0) { + const uint32_t toRead = std::min(remaining, CHUNK_SIZE); + if (fread(chunk, sizeof(s16), toRead, f) != toRead) { + free(buf); + fclose(f); + return false; + } + + for (uint32_t i = 0; i < toRead; ++i) { + const s16 sample = static_cast(chunk[i] * scale); + if (mono) { + // Duplicate to both L and R channels for stereo output + out[outIdx++] = sample; // Left + out[outIdx++] = sample; // Right + } else { + out[outIdx++] = sample; + } + } + remaining -= toRead; + } + } + + fclose(f); + + // Zero-fill any padding + if (outSize < bufSize) { + memset((u8*)buf + outSize, 0, bufSize - outSize); + } + + m_cachedSounds[idx] = { buf, bufSize, outSize }; + return true; + } + + void AudioPlayer::playSound(SoundType type) { + // Lock-free check - SAFE with atomic + if (!m_enabled.load(std::memory_order_relaxed)) return; + + const uint32_t idx = static_cast(type); + if (idx >= static_cast(SoundType::Count)) return; + + std::lock_guard lock(m_audioMutex); + + // Check again under lock + if (!m_initialized) return; + + auto& cached = m_cachedSounds[idx]; + if (!cached.buffer) return; + + // Release any finished buffers + AudioOutBuffer* releasedBuffers = nullptr; + u32 releasedCount = 0; + audoutGetReleasedAudioOutBuffer(&releasedBuffers, &releasedCount); + + // Static buffer is safe with mutex protection + static AudioOutBuffer audioBuffer = {}; + audioBuffer = {}; + audioBuffer.buffer = cached.buffer; + audioBuffer.buffer_size = cached.bufferSize; + audioBuffer.data_size = cached.dataSize; + audioBuffer.data_offset = 0; + audioBuffer.next = nullptr; + + AudioOutBuffer* rel = nullptr; + audoutPlayBuffer(&audioBuffer, &rel); + } + + void AudioPlayer::setMasterVolume(float v) { + std::lock_guard lock(m_audioMutex); + m_masterVolume = std::clamp(v, 0.0f, 1.0f); + } + + void AudioPlayer::setEnabled(bool e) { + m_enabled.store(e, std::memory_order_relaxed); + } + + bool AudioPlayer::isEnabled() { + return m_enabled.load(std::memory_order_relaxed); + } + + bool AudioPlayer::isDocked() { + Result rc = apmInitialize(); + if (R_FAILED(rc)) return false; + + ApmPerformanceMode perfMode = ApmPerformanceMode_Invalid; + rc = apmGetPerformanceMode(&perfMode); + apmExit(); + + return R_SUCCEEDED(rc) && (perfMode == ApmPerformanceMode_Boost); + } +} \ No newline at end of file diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/debug_funcs.cpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/debug_funcs.cpp index c4c4fec4..0ec0fbd2 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/debug_funcs.cpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/debug_funcs.cpp @@ -12,49 +12,43 @@ namespace ult { #if USING_LOGGING_DIRECTIVE // Define static variables const std::string defaultLogFilePath = "sdmc:/switch/.packages/log.txt"; - std::string logFilePath = defaultLogFilePath; bool disableLogging = true; std::mutex logMutex; - void logMessage(const std::string& message) { - //if (disableLogging) - // return; - + void logMessage(const char* message) { std::time_t currentTime = std::time(nullptr); std::tm* timeInfo = std::localtime(¤tTime); - char timestamp[30]; // Exact size for "[YYYY-MM-DD HH:MM:SS] " + null terminator + char timestamp[30]; strftime(timestamp, sizeof(timestamp), "[%Y-%m-%d %H:%M:%S] ", timeInfo); - // Depending on the directive, use either std::ofstream or stdio functions #if !USING_FSTREAM_DIRECTIVE - // Use stdio functions to open, write, and close the file { - std::lock_guard lock(logMutex); // Locks the mutex for thread-safe access + std::lock_guard lock(logMutex); - FILE* file = fopen(logFilePath.c_str(), "a"); // Open the file in append mode + FILE* file = fopen(logFilePath.c_str(), "a"); if (file != nullptr) { - fprintf(file, "%s%s\n", timestamp, message.c_str()); - fclose(file); // Close the file after writing - } else { - // Handle error when file opening fails (if necessary) - // printf("Failed to open log file: %s\n", logFilePath.c_str()); + fputs(timestamp, file); + fputs(message, file); + fputc('\n', file); + fclose(file); } } #else - // Use std::ofstream if !USING_FSTREAM_DIRECTIVE is not defined { - std::lock_guard lock(logMutex); // Locks the mutex for the duration of this block + std::lock_guard lock(logMutex); std::ofstream file(logFilePath.c_str(), std::ios::app); if (file.is_open()) { file << timestamp << message << "\n"; - } else { - // Handle error when file opening fails - // std::cerr << "Failed to open log file: " << logFilePath << std::endl; } } #endif } + + // Overload for std::string + void logMessage(const std::string& message) { + logMessage(message.c_str()); + } #endif } \ No newline at end of file diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/download_funcs.cpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/download_funcs.cpp index c3d9fbad..3ff0216e 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/download_funcs.cpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/download_funcs.cpp @@ -22,8 +22,9 @@ namespace ult { -size_t DOWNLOAD_READ_BUFFER = 16*1024;//64 * 1024;//4096*10; -size_t DOWNLOAD_WRITE_BUFFER = 16*1024;//64 * 1024; +// Base loader definitions +size_t DOWNLOAD_READ_BUFFER = 8*1024;//64 * 1024;//4096*10; +size_t DOWNLOAD_WRITE_BUFFER = 8*1024;//64 * 1024; size_t UNZIP_READ_BUFFER = 32*1024;//131072*2;//4096*4; size_t UNZIP_WRITE_BUFFER = 16*1024;//131072*2;//4096*4; @@ -32,6 +33,9 @@ size_t UNZIP_WRITE_BUFFER = 16*1024;//131072*2;//4096*4; //const std::string cacertPath = "sdmc:/config/ultrahand/cacert.pem"; //const std::string cacertURL = "https://curl.se/ca/cacert.pem"; +// User agent string for curl requests +static constexpr const char* userAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"; + // Shared atomic flag to indicate whether to abort the download operation std::atomic abortDownload(false); // Define an atomic bool for interpreter completion @@ -44,17 +48,22 @@ static std::mutex curlInitMutex; static std::atomic curlInitialized(false); - -struct FileDeleter { - void operator()(FILE* f) const { if (f) fclose(f); } +// Definition of CurlDeleter +struct CurlDeleter { + void operator()(CURL* curl) const noexcept { + if (curl) { + curl_easy_cleanup(curl); + } + } }; -// Definition of CurlDeleter -void CurlDeleter::operator()(CURL* curl) const { - if (curl) { - curl_easy_cleanup(curl); +struct FileDeleter { + void operator()(FILE* f) const { + if (f) { + fclose(f); + } } -} +}; // Callback function to write received data to a file. #if !USING_FSTREAM_DIRECTIVE @@ -71,8 +80,8 @@ size_t writeCallback(void* ptr, size_t size, size_t nmemb, FILE* stream) { size_t writeCallback(void* ptr, size_t size, size_t nmemb, std::ostream* stream) { if (!ptr || !stream) return 0; auto& file = *static_cast(stream); - //size_t totalBytes = size * nmemb; - file.write(static_cast(ptr), size * nmemb); + const size_t totalBytes = size * nmemb; + file.write(static_cast(ptr), totalBytes); return totalBytes; } #endif @@ -97,30 +106,32 @@ int progressCallback(void *ptr, curl_off_t totalToDownload, curl_off_t nowDownlo } // Global initialization function -void initializeCurl() { - std::lock_guard lock(curlInitMutex); - if (!curlInitialized.load(std::memory_order_acquire)) { - const CURLcode res = curl_global_init(CURL_GLOBAL_DEFAULT); - if (res != CURLE_OK) { - #if USING_LOGGING_DIRECTIVE - if (!disableLogging) - logMessage("curl_global_init() failed: " + std::string(curl_easy_strerror(res))); - #endif - // Handle error appropriately, possibly exit the program - } else { - curlInitialized.store(true, std::memory_order_release); - } - } -} +//void initializeCurl() { +// std::lock_guard lock(curlInitMutex); +// if (!curlInitialized.load(std::memory_order_acquire)) { +// const CURLcode res = curl_global_init(CURL_GLOBAL_DEFAULT); +// if (res != CURLE_OK) { +// #if USING_LOGGING_DIRECTIVE +// if (!disableLogging) +// logMessage("curl_global_init() failed: " + std::string(curl_easy_strerror(res))); +// #endif +// // Handle error appropriately, possibly exit the program +// } else { +// curlInitialized.store(true, std::memory_order_release); +// } +// } +//} // Global cleanup function -void cleanupCurl() { - std::lock_guard lock(curlInitMutex); - if (curlInitialized.load(std::memory_order_acquire)) { - curl_global_cleanup(); - curlInitialized.store(false, std::memory_order_release); - } -} +//void cleanupCurl() { +// std::lock_guard lock(curlInitMutex); +// if (curlInitialized.load(std::memory_order_acquire)) { +// curl_global_cleanup(); +// curlInitialized.store(false, std::memory_order_release); +// } +//} + +std::unique_ptr globalWriteBuffer; /** * @brief Downloads a file from a URL to a specified destination. @@ -181,16 +192,27 @@ bool downloadFile(const std::string& url, const std::string& toDestination, bool } // ADD THIS: Set up write buffer for better performance - std::unique_ptr writeBuffer; + //std::unique_ptr globalWriteBuffer; if (DOWNLOAD_WRITE_BUFFER > 0) { - writeBuffer = std::make_unique(DOWNLOAD_WRITE_BUFFER); + //if (!globalWriteBuffer) + globalWriteBuffer = std::make_unique(DOWNLOAD_WRITE_BUFFER); // _IOFBF = full buffering, _IOLBF = line buffering, _IONBF = no buffering - setvbuf(file.get(), writeBuffer.get(), _IOFBF, DOWNLOAD_WRITE_BUFFER); + setvbuf(file.get(), globalWriteBuffer.get(), _IOFBF, DOWNLOAD_WRITE_BUFFER); } + + //setvbuf(file.get(), NULL, _IOFBF, DOWNLOAD_WRITE_BUFFER); #endif // Ensure curl is initialized - initializeCurl(); + //initializeCurl(); + + //if (!R_SUCCEEDED(socketInitializeDefault())) { + // #if USING_LOGGING_DIRECTIVE + // if (!disableLogging) + // logMessage("Failed to initialize socket."); + // #endif + // return false; + //} std::unique_ptr curl(curl_easy_init()); if (!curl) { @@ -202,6 +224,7 @@ bool downloadFile(const std::string& url, const std::string& toDestination, bool file.close(); #else file.reset(); + globalWriteBuffer.reset(); #endif return false; } @@ -231,7 +254,8 @@ bool downloadFile(const std::string& url, const std::string& toDestination, bool } curl_easy_setopt(curl.get(), CURLOPT_USERAGENT, userAgent); - curl_easy_setopt(curl.get(), CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2TLS); // Enable HTTP/2 + curl_easy_setopt(curl.get(), CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1); // Enable HTTP/2 + curl_easy_setopt(curl.get(), CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4); curl_easy_setopt(curl.get(), CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2); // Force TLS 1.2 curl_easy_setopt(curl.get(), CURLOPT_FOLLOWLOCATION, 1L); @@ -242,17 +266,56 @@ bool downloadFile(const std::string& url, const std::string& toDestination, bool curl_easy_setopt(curl.get(), CURLOPT_LOW_SPEED_LIMIT, 1L); // 1 byte/s (virtually any progress) curl_easy_setopt(curl.get(), CURLOPT_LOW_SPEED_TIME, 60L); // 1 minutes of no progress + //curl_easy_setopt(curl.get(), CURLOPT_DNS_USE_GLOBAL_CACHE, 0L); + //curl_easy_setopt(curl.get(), CURLOPT_FORBID_REUSE, 1L); + //curl_easy_setopt(curl.get(), CURLOPT_CLOSESOCKETDATA, NULL); // ensure no dangling sockets + //curl_easy_setopt(curl.get(), CURLOPT_TCP_NODELAY, 1L); + CURLcode result = curl_easy_perform(curl.get()); + // Detect if download was aborted + //const bool wasAborted = (result == CURLE_ABORTED_BY_CALLBACK || + // abortDownload.load(std::memory_order_acquire)); + + #if USING_FSTREAM_DIRECTIVE file.close(); #else file.reset(); + globalWriteBuffer.reset(); #endif + curl.reset(); + + // Always cleanup global state + //curl_global_cleanup(); + // + //// Sleep to let cleanup finish + //for (int i = 0; i < 10; ++i) { + // svcSleepThread(50'000'000ULL); + //} + // + //// Explicitly reinitialize for next download + //curl_global_init(CURL_GLOBAL_DEFAULT); + + // CRITICAL: For aborted downloads, give curl time to clean up network/SSL state + // before destroying the handle. This prevents memory leaks in the global heap. + //if (wasAborted) { + // for (int i = 0; i < 10; ++i) { + // svcSleepThread(50'000'000ULL); // 50ms x 10 = 500ms total + // } + //} + + //cleanupCurl(); + + //socketExit(); + if (result != CURLE_OK) { #if USING_LOGGING_DIRECTIVE - if (result == CURLE_OPERATION_TIMEDOUT) { + if (result == CURLE_ABORTED_BY_CALLBACK) { + if (!disableLogging) + logMessage("Download aborted by user: " + url); + } else if (result == CURLE_OPERATION_TIMEDOUT) { if (!disableLogging) logMessage("Download timed out: " + url); } else if (result == CURLE_COULDNT_CONNECT) { @@ -264,7 +327,6 @@ bool downloadFile(const std::string& url, const std::string& toDestination, bool } #endif deleteFileOrDirectory(tempFilePath); - // Only update percentage if we're tracking it if (!noPercentagePolling) { downloadPercentage.store(-1, std::memory_order_release); } @@ -558,7 +620,10 @@ bool unzipFile(const std::string& zipFilePath, const std::string& toDestination) // Single large buffer for extraction - reused for all files const size_t bufferSize = UNZIP_WRITE_BUFFER; - std::unique_ptr buffer = std::make_unique(bufferSize); + //std::unique_ptr buffer = std::make_unique(bufferSize); + + globalWriteBuffer = std::make_unique(bufferSize); + char filenameBuffer[512]; // Stack allocated for filename reading // Progress tracking variables - OPTIMIZED for smooth byte-based tracking @@ -693,14 +758,14 @@ bool unzipFile(const std::string& zipFilePath, const std::string& toDestination) fileBytesProcessed = 0; - while ((bytesRead = unzReadCurrentFile(zipFile, buffer.get(), bufferSize)) > 0) { + while ((bytesRead = unzReadCurrentFile(zipFile, globalWriteBuffer.get(), bufferSize)) > 0) { if (abortUnzip.load(std::memory_order_relaxed)) { extractSuccess = false; break; // RAII will handle cleanup } // Write data to file - if (outputFile.write(buffer.get(), bytesRead) != static_cast(bytesRead)) { + if (outputFile.write(globalWriteBuffer.get(), bytesRead) != static_cast(bytesRead)) { extractSuccess = false; break; } @@ -780,6 +845,8 @@ bool unzipFile(const std::string& zipFilePath, const std::string& toDestination) result = unzGoToNextFile(zipFile); } + globalWriteBuffer.reset(); + // Check final abort state if (abortUnzip.load(std::memory_order_relaxed)) { unzipPercentage.store(-1, std::memory_order_release); diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/global_vars.cpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/global_vars.cpp index edaf41b7..777b89fd 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/global_vars.cpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/global_vars.cpp @@ -51,10 +51,11 @@ namespace ult { const std::string LANG_PATH = BASE_CONFIG_PATH + "lang/"; const std::string THEMES_PATH = BASE_CONFIG_PATH + "themes/"; const std::string WALLPAPERS_PATH = BASE_CONFIG_PATH + "wallpapers/"; + const std::string SOUNDS_PATH = BASE_CONFIG_PATH + "sounds/"; const std::string FLAGS_PATH = BASE_CONFIG_PATH + "flags/"; const std::string NOTIFICATIONS_PATH = BASE_CONFIG_PATH + "notifications/"; const std::string PAYLOADS_PATH = BASE_CONFIG_PATH + "payloads/"; - const std::string HB_APPSTORE_JSON = SWITCH_PATH + ".appstore/.get/packages/UltrahandOverlay/info.json"; + const std::string HB_APPSTORE_JSON = SWITCH_PATH + "appstore/.get/packages/UltrahandOverlay/info.json"; std::string THEME_CONFIG_INI_PATH = BASE_CONFIG_PATH + THEME_FILENAME; std::string WALLPAPER_PATH = BASE_CONFIG_PATH + WALLPAPER_FILENAME; const std::string DOWNLOADS_PATH = BASE_CONFIG_PATH + "downloads/"; @@ -83,6 +84,7 @@ namespace ult { const std::string OLD_NX_OVLLOADER_ZIP_URL = GITHUB_BASE_URL + "nx-ovlloader/releases/download/v1.0.8/nx-ovlloader.zip"; const std::string OLD_NX_OVLLOADER_PLUS_ZIP_URL = GITHUB_BASE_URL + "nx-ovlloader/releases/download/v1.0.8/nx-ovlloader+.zip"; const std::string UPDATER_PAYLOAD_URL = GITHUB_RAW_BASE_URL + "Ultrahand-Overlay/main/payloads/ultrahand_updater.bin"; + const std::string SOUND_EFFECTS_URL = GITHUB_RAW_BASE_URL + "Ultrahand-Overlay/main/sounds/sounds.zip"; // Launch options const std::string LAUNCH_ARGS_STR = "launch_args"; diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/haptics.cpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/haptics.cpp new file mode 100644 index 00000000..59a4b5cd --- /dev/null +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/haptics.cpp @@ -0,0 +1,202 @@ +/******************************************************************************** + * File: haptics.cpp + * Author: ppkantorski + * Description: + * This source file provides implementations for the functions declared in + * haptics.hpp. These functions manage haptic feedback for the Ultrahand Overlay + * using libnx’s vibration interfaces. It includes routines for initializing + * rumble devices, sending vibration patterns, and handling single or double + * click feedback with timing control. Thread safety is maintained through + * atomic operations and synchronization mechanisms. + * + * For the latest updates and contributions, visit the project's GitHub repository. + * (GitHub Repository: https://github.com/ppkantorski/Ultrahand-Overlay) + * + * Note: Please be aware that this notice cannot be altered or removed. It is a part + * of the project's documentation and must remain intact. + * + * Licensed under both GPLv2 and CC-BY-4.0 + * Copyright (c) 2025 ppkantorski + ********************************************************************************/ + +#include "haptics.hpp" + +namespace ult { + + // ===== Internal state (private to this file) ===== + //bool rumbleInitialized = false; + static HidVibrationDeviceHandle vibHandheld; + static HidVibrationDeviceHandle vibPlayer1Left; + static HidVibrationDeviceHandle vibPlayer1Right; + static u64 rumbleStartTick = 0; + static u64 doubleClickTick = 0; + static u8 doubleClickPulse = 0; + + // ===== Shared flags (accessible globally) ===== + std::atomic rumbleActive{false}; + std::atomic doubleClickActive{false}; + + // ===== Constants ===== + static constexpr u64 RUMBLE_DURATION_NS = 30'000'000ULL; + static constexpr u64 DOUBLE_CLICK_PULSE_DURATION_NS = 30'000'000ULL; + static constexpr u64 DOUBLE_CLICK_GAP_NS = 100'000'000ULL; + + static constexpr HidVibrationValue clickDocked = { + .amp_low = 0.20f, + .freq_low = 100.0f, + .amp_high = 0.80f, + .freq_high = 300.0f + }; + + static constexpr HidVibrationValue clickHandheld = { + .amp_low = 0.25f, + .freq_low = 100.0f, + .amp_high = 1.0f, + .freq_high = 300.0f + }; + + static constexpr HidVibrationValue vibrationStop{0}; + + // ===== Internal helpers ===== + static void initController(HidNpadIdType npad, HidVibrationDeviceHandle* handles, int count) { + const u32 styleMask = hidGetNpadStyleSet(npad); + if (styleMask) + hidInitializeVibrationDevices(handles, count, npad, static_cast(styleMask)); + } + + static void sendVibration(const HidVibrationValue* value) { + if (hidGetNpadStyleSet(HidNpadIdType_Handheld)) + hidSendVibrationValue(vibHandheld, value); + + if (hidGetNpadStyleSet(HidNpadIdType_No1)) { + hidSendVibrationValue(vibPlayer1Left, value); + hidSendVibrationValue(vibPlayer1Right, value); + } + } + + // ===== Public API ===== + void initRumble() { + //if (rumbleInitialized) return; + + // Try to initialize whatever is available + // Don't check if controllers exist - let initController handle it + initController(HidNpadIdType_Handheld, &vibHandheld, 1); + + HidVibrationDeviceHandle handles[2]; + initController(HidNpadIdType_No1, handles, 2); + vibPlayer1Left = handles[0]; + vibPlayer1Right = handles[1]; + + // Only mark as initialized if at least one controller was found + hidGetNpadStyleSet(HidNpadIdType_Handheld); + hidGetNpadStyleSet(HidNpadIdType_No1); + + //rumbleInitialized = (handheldStyle || player1Style); + + // If neither exist, stay uninitialized so we retry later + } + + //void deinitRumble() { + // rumbleInitialized = false; + //} + + void checkAndReinitRumble() { + static u32 lastHandheldStyle = 0; + static u32 lastPlayer1Style = 0; + + const u32 currentHandheldStyle = hidGetNpadStyleSet(HidNpadIdType_Handheld); + const u32 currentPlayer1Style = hidGetNpadStyleSet(HidNpadIdType_No1); + + // If not initialized but controllers exist, try to init + // This handles the boot race condition where HID reports controllers + // but vibration subsystem isn't ready yet + //if (!rumbleInitialized && (currentHandheldStyle || currentPlayer1Style)) { + // initRumble(); + //} + + // Reinit if controller configuration changed + if (currentHandheldStyle != lastHandheldStyle || currentPlayer1Style != lastPlayer1Style) { + //rumbleInitialized = false; + initRumble(); + } + // Update last style tracking regardless + lastHandheldStyle = currentHandheldStyle; + lastPlayer1Style = currentPlayer1Style; + } + + void rumbleClick() { + //if (!rumbleInitialized) { + // initRumble(); + // if (!rumbleInitialized) return; + //} + + sendVibration(hidGetNpadStyleSet(HidNpadIdType_Handheld) ? &clickHandheld : &clickDocked); + rumbleActive.store(true, std::memory_order_release); + rumbleStartTick = armGetSystemTick(); + } + + void rumbleDoubleClick() { + //if (!rumbleInitialized) { + // initRumble(); + // if (!rumbleInitialized) return; + //} + + sendVibration(hidGetNpadStyleSet(HidNpadIdType_Handheld) ? &clickHandheld : &clickDocked); + doubleClickActive.store(true, std::memory_order_release); + doubleClickPulse = 1; + doubleClickTick = armGetSystemTick(); + } + + void processRumbleStop(u64 nowNs) { + if (rumbleActive.load(std::memory_order_acquire) && + nowNs - armTicksToNs(rumbleStartTick) >= RUMBLE_DURATION_NS) { + sendVibration(&vibrationStop); + rumbleActive.store(false, std::memory_order_release); + } + } + + void processRumbleDoubleClick(u64 nowNs) { + if (!doubleClickActive.load(std::memory_order_acquire)) return; + + const u64 elapsed = nowNs - armTicksToNs(doubleClickTick); + + switch (doubleClickPulse) { + case 1: + if (elapsed >= DOUBLE_CLICK_PULSE_DURATION_NS) { + sendVibration(&vibrationStop); + doubleClickPulse = 2; + doubleClickTick = armGetSystemTick(); + } + break; + + case 2: + if (elapsed >= DOUBLE_CLICK_GAP_NS) { + sendVibration(hidGetNpadStyleSet(HidNpadIdType_Handheld) ? &clickHandheld : &clickDocked); + doubleClickPulse = 3; + doubleClickTick = armGetSystemTick(); + } + break; + + case 3: + if (elapsed >= DOUBLE_CLICK_PULSE_DURATION_NS) { + sendVibration(&vibrationStop); + doubleClickActive.store(false, std::memory_order_release); + doubleClickPulse = 0; + } + break; + } + } + + void rumbleDoubleClickStandalone() { + sendVibration(hidGetNpadStyleSet(HidNpadIdType_Handheld) ? &clickHandheld : &clickDocked); + svcSleepThread(DOUBLE_CLICK_PULSE_DURATION_NS); + + sendVibration(&vibrationStop); + svcSleepThread(DOUBLE_CLICK_GAP_NS); + + sendVibration(hidGetNpadStyleSet(HidNpadIdType_Handheld) ? &clickHandheld : &clickDocked); + svcSleepThread(DOUBLE_CLICK_PULSE_DURATION_NS); + + sendVibration(&vibrationStop); + } +} \ No newline at end of file diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/ini_funcs.cpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/ini_funcs.cpp index 939c9ab5..47551c5a 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/ini_funcs.cpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/ini_funcs.cpp @@ -2404,7 +2404,7 @@ namespace ult { } // Clear strings to reuse capacity - strLine.clear(); + //strLine.clear(); currentSection.clear(); } @@ -2440,7 +2440,7 @@ namespace ult { for (const auto& kv : section.second) { fprintf(file, "%s=%s\n", kv.first.c_str(), kv.second.c_str()); } - fprintf(file, "\n"); // Separate sections with a newline + fputc('\n', file); // Separate sections with a newline } fclose(file); diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/json_funcs.cpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/json_funcs.cpp index 132dffc1..b4acb50e 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/json_funcs.cpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/json_funcs.cpp @@ -365,35 +365,35 @@ namespace ult { return success; } - void pushNotificationJson(const std::string& text, size_t fontSize) { + void pushNotificationJson(const std::string& appID, const std::string& text, size_t fontSize) { u64 tick = armGetSystemTick(); - std::string filename = "20-" + std::to_string(tick) + ".notify"; // priority 20 default - + std::string filename = appID + "-" + std::to_string(tick) + ".notify"; // priority 20 default + // Build full path - std::string fullPath = NOTIFICATIONS_PATH + filename; - + const std::string fullPath = NOTIFICATIONS_PATH + filename; + // Create JSON object cJSON* notif = cJSON_CreateObject(); if (!notif) return; - + cJSON_AddStringToObject(notif, "text", text.c_str()); cJSON_AddNumberToObject(notif, "font_size", static_cast(fontSize)); //cJSON_AddNumberToObject(notif, "arrival_ns", static_cast(armTicksToNs(tick))); - + // Serialize JSON char* rendered = cJSON_PrintUnformatted(notif); if (!rendered) { cJSON_Delete(notif); return; } - + // Write to file (C-style) FILE* file = fopen(fullPath.c_str(), "wb"); if (file) { fwrite(rendered, 1, strlen(rendered), file); fclose(file); } - + cJSON_free(rendered); cJSON_Delete(notif); } diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/list_funcs.cpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/list_funcs.cpp index f5128d90..b18edabf 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/list_funcs.cpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/list_funcs.cpp @@ -21,6 +21,8 @@ #include namespace ult { + static constexpr const char* UNABLE_TO_OPEN_FILE = "Unable to open file: "; + // Thread-safe file access mutex static std::mutex file_access_mutex; @@ -92,7 +94,7 @@ namespace ult { FILE* file = fopen(filePath.c_str(), "r"); if (!file) { #if USING_LOGGING_DIRECTIVE - logMessage("Unable to open file: " + filePath); + logMessage(UNABLE_TO_OPEN_FILE + filePath); #endif return lines; } @@ -126,7 +128,7 @@ namespace ult { std::ifstream file(filePath); if (!file.is_open()) { #if USING_LOGGING_DIRECTIVE - logMessage("Unable to open file: " + filePath); + logMessage(UNABLE_TO_OPEN_FILE + filePath); #endif return lines; } @@ -161,7 +163,7 @@ namespace ult { FILE* file = fopen(listPath.c_str(), "r"); if (!file) { #if USING_LOGGING_DIRECTIVE - logMessage("Unable to open file: " + listPath); + logMessage(UNABLE_TO_OPEN_FILE + listPath); #endif return ""; } @@ -200,7 +202,7 @@ namespace ult { std::ifstream file(listPath); if (!file.is_open()) { #if USING_LOGGING_DIRECTIVE - logMessage("Unable to open file: " + listPath); + logMessage(UNABLE_TO_OPEN_FILE + listPath); #endif return ""; } @@ -288,7 +290,7 @@ namespace ult { FILE* file = fopen(filePath.c_str(), "r"); if (!file) { #if USING_LOGGING_DIRECTIVE - logMessage("Unable to open file: " + filePath); + logMessage(UNABLE_TO_OPEN_FILE + filePath); #endif return lines; } @@ -310,7 +312,7 @@ namespace ult { std::ifstream file(filePath); if (!file.is_open()) { #if USING_LOGGING_DIRECTIVE - logMessage("Unable to open file: " + filePath); + logMessage(UNABLE_TO_OPEN_FILE + filePath); #endif return lines; } @@ -335,7 +337,7 @@ namespace ult { FILE* file = fopen(filePath.c_str(), "w"); if (!file) { #if USING_LOGGING_DIRECTIVE - logMessage("Failed to open file: " + filePath); + logMessage(UNABLE_TO_OPEN_FILE + filePath); #endif return; } @@ -349,7 +351,7 @@ namespace ult { std::ofstream file(filePath); if (!file.is_open()) { #if USING_LOGGING_DIRECTIVE - logMessage("Failed to open file: " + filePath); + logMessage(UNABLE_TO_OPEN_FILE + filePath); #endif return; } @@ -362,106 +364,151 @@ namespace ult { #endif } + // Helper function for streaming comparison + void streamCompareAndWrite(const std::string& streamFilePath, + const std::unordered_set& compareSet, + const std::string& outputTxtFilePath) { + std::lock_guard lock(file_access_mutex); + + #if !USING_FSTREAM_DIRECTIVE + FILE* streamFile = fopen(streamFilePath.c_str(), "r"); + if (!streamFile) return; + + FILE* outputFile = fopen(outputTxtFilePath.c_str(), "w"); + if (!outputFile) { + fclose(streamFile); + return; + } + + static constexpr size_t BUFFER_SIZE = 8192; + char buffer[BUFFER_SIZE]; + size_t len; + + while (fgets(buffer, BUFFER_SIZE, streamFile)) { + len = strlen(buffer); + if (len > 0 && buffer[len - 1] == '\n') { + buffer[len - 1] = '\0'; + } + + if (compareSet.count(std::string(buffer))) { + fprintf(outputFile, "%s\n", buffer); + } + } + + fclose(streamFile); + fclose(outputFile); + + #else + std::ifstream streamFile(streamFilePath); + if (!streamFile.is_open()) return; + + std::ofstream outputFile(outputTxtFilePath); + if (!outputFile.is_open()) return; + + std::string line; + while (std::getline(streamFile, line)) { + if (compareSet.count(line)) { + outputFile << line << '\n'; + } + } + #endif + } // Function to compare two file lists and save duplicates to an output file void compareFilesLists(const std::string& txtFilePath1, const std::string& txtFilePath2, const std::string& outputTxtFilePath) { // Read files into sets std::unordered_set fileSet1 = readSetFromFile(txtFilePath1); std::unordered_set fileSet2 = readSetFromFile(txtFilePath2); - std::unordered_set duplicateFiles; - - // Find intersection (common elements) between the two sets - for (const auto& entry : fileSet1) { - if (fileSet2.count(entry)) { - duplicateFiles.insert(entry); + + // Always work with the smaller set for better performance + if (fileSet1.size() <= fileSet2.size()) { + // fileSet1 is smaller or equal - modify it + for (auto it = fileSet1.begin(); it != fileSet1.end();) { + if (fileSet2.count(*it) == 0) { + it = fileSet1.erase(it); + } else { + ++it; + } } - } - - // Write the duplicates to the output file - writeSetToFile(duplicateFiles, outputTxtFilePath); - } - - // Helper function to read a text file and process each line with a callback - void processFileLines(const std::string& filePath, const std::function& callback) { - std::lock_guard lock(file_access_mutex); - - #if !USING_FSTREAM_DIRECTIVE - FILE* file = fopen(filePath.c_str(), "r"); - if (!file) { - #if USING_LOGGING_DIRECTIVE - logMessage("Unable to open file: " + filePath); - #endif - return; - } - - // OPTIMIZATION 1: Larger buffer for better I/O performance - static constexpr size_t BUFFER_SIZE = 8192; - char buffer[BUFFER_SIZE]; - - while (fgets(buffer, BUFFER_SIZE, file)) { - // OPTIMIZATION 2: Find newline directly instead of strlen() - char* newlinePos = strchr(buffer, '\n'); - if (newlinePos) { - *newlinePos = '\0'; // Remove newline in-place + writeSetToFile(fileSet1, outputTxtFilePath); + } else { + // fileSet2 is smaller - modify it instead + for (auto it = fileSet2.begin(); it != fileSet2.end();) { + if (fileSet1.count(*it) == 0) { + it = fileSet2.erase(it); + } else { + ++it; + } } - - // OPTIMIZATION 3: Pass buffer directly - no string construction overhead - callback(std::string(buffer)); + writeSetToFile(fileSet2, outputTxtFilePath); } - - fclose(file); - - #else - // OPTIMIZATION 4: Use faster I/O for fstream version - std::ifstream file(filePath); - if (!file.is_open()) { - #if USING_LOGGING_DIRECTIVE - logMessage("Unable to open file: " + filePath); - #endif - return; - } - - // OPTIMIZATION 5: Reserve string capacity to avoid reallocations - std::string line; - line.reserve(256); // Reasonable default for most lines - - while (std::getline(file, line)) { - callback(line); - } - #endif } - void compareWildcardFilesLists( const std::string& wildcardPatternFilePath, const std::string& txtFilePath, const std::string& outputTxtFilePath ) { - // STEP 1: Read target file into fast lookup set (only once) - const std::unordered_set targetLines = readSetFromFile(txtFilePath); + std::unordered_set targetLines = readSetFromFile(txtFilePath); std::unordered_set duplicates; - // STEP 2: Get wildcard files - std::vector wildcardFiles = getFilesListByWildcards(wildcardPatternFilePath); + auto wildcardFiles = getFilesListByWildcards(wildcardPatternFilePath); - // STEP 3: Process each wildcard file line-by-line (minimum memory) + static constexpr size_t BUFFER_SIZE = 8192; + for (auto& filePath : wildcardFiles) { - if (filePath == txtFilePath) { - filePath = ""; + if (filePath == txtFilePath || targetLines.empty()) { + filePath = ""; // Clear early + continue; + } + + std::lock_guard lock(file_access_mutex); + + #if !USING_FSTREAM_DIRECTIVE + FILE* file = fopen(filePath.c_str(), "r"); + if (!file) { + #if USING_LOGGING_DIRECTIVE + logMessage(UNABLE_TO_OPEN_FILE + filePath); + #endif continue; } - - // Process line-by-line without loading entire file into memory - processFileLines(filePath, [&](const std::string& line) { - // O(1) lookup + O(1) insert if duplicate found - if (targetLines.count(line)) { - duplicates.insert(line); + + + char buffer[BUFFER_SIZE]; + + while (fgets(buffer, BUFFER_SIZE, file) && !targetLines.empty()) { // Early exit! + char* newlinePos = strchr(buffer, '\n'); + if (newlinePos) *newlinePos = '\0'; + + auto it = targetLines.find(std::string(buffer)); + if (it != targetLines.end()) { + duplicates.emplace(std::move(*it)); // Move instead of copy + targetLines.erase(it); } - }); - filePath = ""; + } + fclose(file); + + #else + std::ifstream file(filePath); + if (!file.is_open()) { + #if USING_LOGGING_DIRECTIVE + logMessage(UNABLE_TO_OPEN_FILE + filePath); + #endif + continue; + } + + std::string line; + while (std::getline(file, line) && !targetLines.empty()) { // Early exit! + auto it = targetLines.find(line); + if (it != targetLines.end()) { + duplicates.emplace(std::move(*it)); // Move instead of copy + targetLines.erase(it); + } + } + #endif + filePath = ""; // Clear after processing - reduces vector memory footprint } - // STEP 4: Write results writeSetToFile(duplicates, outputTxtFilePath); } } \ No newline at end of file diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/mod_funcs.cpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/mod_funcs.cpp index 29cc246e..aacede6e 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/mod_funcs.cpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/mod_funcs.cpp @@ -22,9 +22,9 @@ namespace ult { //const std::string CHEAT_HEADER = "// auto generated by pchtxt2cheat\n\n"; - const std::string CHEAT_TYPE = "04000000"; - const std::string CHEAT_EXT = ".txt"; - const std::string CHEAT_ENCODING = "ascii"; + static const std::string CHEAT_TYPE = "04000000"; + static const std::string CHEAT_EXT = ".txt"; + static const std::string CHEAT_ENCODING = "ascii"; @@ -408,33 +408,33 @@ namespace ult { // Corrected helper function to convert values to big-endian format - uint32_t toBigEndian(uint32_t value) { - return ((value & 0x000000FF) << 24) | - ((value & 0x0000FF00) << 8) | - ((value & 0x00FF0000) >> 8) | - ((value & 0xFF000000) >> 24); - } - - uint16_t toBigEndian(uint16_t value) { - return ((value & 0x00FF) << 8) | - ((value & 0xFF00) >> 8); - } + //uint32_t toBigEndian(uint32_t value) { + // return ((value & 0x000000FF) << 24) | + // ((value & 0x0000FF00) << 8) | + // ((value & 0x00FF0000) >> 8) | + // ((value & 0xFF000000) >> 24); + //} + // + //uint16_t toBigEndian(uint16_t value) { + // return ((value & 0x00FF) << 8) | + // ((value & 0xFF00) >> 8); + //} // Helper function to convert a vector of bytes to a hex string for logging - std::string hexToString(const std::vector& bytes) { - StringStream oss; // Use your custom StringStream - oss.hex(); // Enable hex mode for the stream - - for (uint8_t byte : bytes) { - if (byte < 0x10) { - oss << "0"; // Append leading zero for single-digit hex values - } - oss << static_cast(byte); // Convert byte to int and then append it - } - - return oss.str(); // Return the final hex string - } + //std::string hexToString(const std::vector& bytes) { + // StringStream oss; // Use your custom StringStream + // oss.hex(); // Enable hex mode for the stream + // + // for (uint8_t byte : bytes) { + // if (byte < 0x10) { + // oss << "0"; // Append leading zero for single-digit hex values + // } + // oss << static_cast(byte); // Convert byte to int and then append it + // } + // + // return oss.str(); // Return the final hex string + //} diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/path_funcs.cpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/path_funcs.cpp index 2c593a15..fed30684 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/path_funcs.cpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/path_funcs.cpp @@ -30,6 +30,8 @@ namespace ult { std::mutex logMutex2; // Mutex for thread-safe logging (defined here, declared as extern in header) + static std::vector fileList; + // RAII wrapper for FILE* to ensure proper cleanup class FileGuard { private: @@ -400,204 +402,233 @@ namespace ult { */ void deleteFileOrDirectoryByPattern(const std::string& pathPattern, const std::string& logSource) { //logMessage("pathPattern: "+pathPattern); - std::vector fileList = getFilesListByWildcards(pathPattern); + fileList = getFilesListByWildcards(pathPattern); for (auto& path : fileList) { //logMessage("path: "+path); deleteFileOrDirectory(path, logSource); path = ""; } + fileList.clear(); + fileList.shrink_to_fit(); + } + + // Helper function to reverse a log file safely + void reverseLogFile(const std::string& logFilePath) { + std::vector lines; + + #if !USING_FSTREAM_DIRECTIVE + FILE* file = fopen(logFilePath.c_str(), "r"); + if (!file) return; + + setvbuf(file, nullptr, _IOFBF, 8192); + + static constexpr size_t BUFFER_SIZE = 8192; + char buffer[BUFFER_SIZE]; + + while (fgets(buffer, BUFFER_SIZE, file)) { + size_t len = strlen(buffer); + if (len > 0 && buffer[len - 1] == '\n') buffer[len - 1] = '\0'; + lines.emplace_back(buffer); // std::string constructor ensures proper termination + } + fclose(file); + + FILE* outFile = fopen(logFilePath.c_str(), "w"); + if (outFile) { + setvbuf(outFile, nullptr, _IOFBF, 8192); + for (auto it = lines.rbegin(); it != lines.rend(); ++it) { + // Use fprintf instead of fputs to avoid any residual buffer issues + fprintf(outFile, "%s\n", it->c_str()); + } + fflush(outFile); + fclose(outFile); + } + #else + std::ifstream file(logFilePath); + if (!file.is_open()) return; + + static char readBuffer[8192]; + file.rdbuf()->pubsetbuf(readBuffer, sizeof(readBuffer)); + + std::string line; + while (std::getline(file, line)) lines.push_back(std::move(line)); + file.close(); + + std::ofstream outFile(logFilePath); + if (outFile.is_open()) { + static char writeBuffer[8192]; + outFile.rdbuf()->pubsetbuf(writeBuffer, sizeof(writeBuffer)); + + for (auto it = lines.rbegin(); it != lines.rend(); ++it) { + outFile << *it << '\n'; + } + outFile.flush(); + outFile.close(); + } + #endif } void moveDirectory(const std::string& sourcePath, const std::string& destinationPath, const std::string& logSource, const std::string& logDestination) { - + struct stat sourceInfo; if (stat(sourcePath.c_str(), &sourceInfo) != 0) { - #if USING_LOGGING_DIRECTIVE - if (!disableLogging) - logMessage("Source directory doesn't exist: " + sourcePath); - #endif + #if USING_LOGGING_DIRECTIVE + if (!disableLogging) logMessage("Source directory doesn't exist: " + sourcePath); + #endif return; } if (mkdir(destinationPath.c_str(), 0777) != 0 && errno != EEXIST) { - #if USING_LOGGING_DIRECTIVE - if (!disableLogging) - logMessage("Failed to create destination directory: " + destinationPath); - #endif + #if USING_LOGGING_DIRECTIVE + if (!disableLogging) logMessage("Failed to create destination directory: " + destinationPath); + #endif return; } - // Batch logging optimization - collect successful operations instead of logging immediately - std::vector successfulSources, successfulDestinations; bool needsLogging = !logSource.empty() || !logDestination.empty(); - - std::vector> stack; - std::vector directoriesToRemove; - - stack.push_back({sourcePath, destinationPath}); - - // Variables moved outside the loop to avoid repeated allocation - std::string name, fullPathSrc, fullPathDst; - dirent* entry; - DIR* dir; - - std::string currentSource, currentDestination; - while (!stack.empty()) { - std::tie(currentSource, currentDestination) = stack.back(); - stack.pop_back(); - - dir = opendir(currentSource.c_str()); - if (!dir) { - #if USING_LOGGING_DIRECTIVE - if (!disableLogging) - logMessage("Failed to open source directory: " + currentSource); - #endif - continue; - } - - while ((entry = readdir(dir)) != nullptr) { - name = entry->d_name; - if (name == "." || name == "..") continue; - - // Optimize string concatenation - avoid repeated substr operations - fullPathSrc = currentSource; - if (!fullPathSrc.empty() && fullPathSrc.back() == '/') { - fullPathSrc.pop_back(); - } - fullPathSrc += "/" + name; - - fullPathDst = currentDestination; - if (!fullPathDst.empty() && fullPathDst.back() == '/') { - fullPathDst.pop_back(); - } - fullPathDst += "/" + name; - - if (entry->d_type == DT_DIR) { - if (mkdir(fullPathDst.c_str(), 0777) != 0 && errno != EEXIST) { - #if USING_LOGGING_DIRECTIVE - if (!disableLogging) - logMessage("Failed to create destination directory: " + fullPathDst); - #endif - continue; - } - stack.push_back({fullPathSrc, fullPathDst}); - directoriesToRemove.push_back(fullPathSrc); - // Log each subdirectory that gets successfully created - if (needsLogging) { - successfulSources.push_back(fullPathSrc + "/"); - successfulDestinations.push_back(fullPathDst + "/"); - } - } else { - remove(fullPathDst.c_str()); - if (rename(fullPathSrc.c_str(), fullPathDst.c_str()) == 0) { - // Batch logging - store successful operations instead of writing immediately + { + std::vector> stack; + std::vector directoriesToRemove; + + stack.push_back({sourcePath, destinationPath}); + + #if !USING_FSTREAM_DIRECTIVE + FILE* logSrcFile = nullptr; + FILE* logDestFile = nullptr; + + if (needsLogging && !logSource.empty()) { + createDirectory(getParentDirFromPath(logSource)); + logSrcFile = fopen(logSource.c_str(), "w"); + if (logSrcFile) setvbuf(logSrcFile, nullptr, _IOFBF, 8192); + } + if (needsLogging && !logDestination.empty()) { + createDirectory(getParentDirFromPath(logDestination)); + logDestFile = fopen(logDestination.c_str(), "w"); + if (logDestFile) setvbuf(logDestFile, nullptr, _IOFBF, 8192); + } + #else + std::unique_ptr logSrcFile, logDestFile; + static char srcBuffer[8192], destBuffer[8192]; + + if (needsLogging && !logSource.empty()) { + createDirectory(getParentDirFromPath(logSource)); + logSrcFile = std::make_unique(logSource); + if (logSrcFile->is_open()) logSrcFile->rdbuf()->pubsetbuf(srcBuffer, sizeof(srcBuffer)); + } + if (needsLogging && !logDestination.empty()) { + createDirectory(getParentDirFromPath(logDestination)); + logDestFile = std::make_unique(logDestination); + if (logDestFile->is_open()) logDestFile->rdbuf()->pubsetbuf(destBuffer, sizeof(destBuffer)); + } + #endif + + std::string fullPathSrc, fullPathDst; + //fullPathSrc.reserve(1024); + //fullPathDst.reserve(1024); + + dirent* entry; + DIR* dir; + const char* name; + + std::string currentSource, currentDestination; + while (!stack.empty()) { + std::tie(currentSource, currentDestination) = stack.back(); + stack.pop_back(); + + dir = opendir(currentSource.c_str()); + if (!dir) { + #if USING_LOGGING_DIRECTIVE + if (!disableLogging) logMessage("Failed to open source directory: " + currentSource); + #endif + continue; + } + + while ((entry = readdir(dir)) != nullptr) { + name = entry->d_name; + if (name[0] == '.' && (name[1] == '\0' || (name[1] == '.' && name[2] == '\0'))) continue; + + fullPathSrc.assign(currentSource); + if (!fullPathSrc.empty() && fullPathSrc.back() != '/') fullPathSrc += '/'; + fullPathSrc += name; + + fullPathDst.assign(currentDestination); + if (!fullPathDst.empty() && fullPathDst.back() != '/') fullPathDst += '/'; + fullPathDst += name; + + if (entry->d_type == DT_DIR) { + if (mkdir(fullPathDst.c_str(), 0777) != 0 && errno != EEXIST) { + #if USING_LOGGING_DIRECTIVE + if (!disableLogging) logMessage("Failed to create destination directory: " + fullPathDst); + #endif + continue; + } + stack.emplace_back(fullPathSrc, fullPathDst); + directoriesToRemove.emplace_back(fullPathSrc); + if (needsLogging) { - successfulSources.push_back(fullPathSrc); - successfulDestinations.push_back(fullPathDst); + #if !USING_FSTREAM_DIRECTIVE + if (logSrcFile) fprintf(logSrcFile, "%s/\n", fullPathSrc.c_str()), fflush(logSrcFile); + if (logDestFile) fprintf(logDestFile, "%s/\n", fullPathDst.c_str()), fflush(logDestFile); + #else + if (logSrcFile && logSrcFile->is_open()) { *logSrcFile << fullPathSrc << "/\n"; logSrcFile->flush(); } + if (logDestFile && logDestFile->is_open()) { *logDestFile << fullPathDst << "/\n"; logDestFile->flush(); } + #endif } } else { - #if USING_LOGGING_DIRECTIVE - if (!disableLogging) - logMessage("Failed to move: " + fullPathSrc); - #endif + remove(fullPathDst.c_str()); + if (rename(fullPathSrc.c_str(), fullPathDst.c_str()) == 0) { + if (needsLogging) { + #if !USING_FSTREAM_DIRECTIVE + if (logSrcFile) fprintf(logSrcFile, "%s\n", fullPathSrc.c_str()), fflush(logSrcFile); + if (logDestFile) fprintf(logDestFile, "%s\n", fullPathDst.c_str()), fflush(logDestFile); + #else + if (logSrcFile && logSrcFile->is_open()) { *logSrcFile << fullPathSrc << '\n'; logSrcFile->flush(); } + if (logDestFile && logDestFile->is_open()) { *logDestFile << fullPathDst << '\n'; logDestFile->flush(); } + #endif + } + } else { + #if USING_LOGGING_DIRECTIVE + if (!disableLogging) logMessage("Failed to move: " + fullPathSrc); + #endif + } } } + closedir(dir); } - closedir(dir); - } - - // Clean up source directories in reverse order - for (auto it = directoriesToRemove.rbegin(); it != directoriesToRemove.rend(); ++it) { - if (rmdir(it->c_str()) != 0) { - #if USING_LOGGING_DIRECTIVE - if (!disableLogging) - logMessage("Failed to delete source directory: " + *it); - #endif + + #if !USING_FSTREAM_DIRECTIVE + if (logSrcFile) fclose(logSrcFile); + if (logDestFile) fclose(logDestFile); + #else + if (logSrcFile) { logSrcFile->flush(); logSrcFile->close(); } + if (logDestFile) { logDestFile->flush(); logDestFile->close(); } + #endif + + // Clean up directories + for (auto it = directoriesToRemove.rbegin(); it != directoriesToRemove.rend(); ++it) { + if (rmdir(it->c_str()) != 0) { + #if USING_LOGGING_DIRECTIVE + if (!disableLogging) logMessage("Failed to delete source directory: " + *it); + #endif + } + } + + if (rmdir(sourcePath.c_str()) != 0) { + #if USING_LOGGING_DIRECTIVE + if (!disableLogging) logMessage("Failed to delete source directory: " + sourcePath); + #endif } } - if (rmdir(sourcePath.c_str()) != 0) { - #if USING_LOGGING_DIRECTIVE - if (!disableLogging) - logMessage("Failed to delete source directory: " + sourcePath); - #endif - } - - // KEY OPTIMIZATION: Batch write all successful operations to log files at the end - // This eliminates the overhead of logging inside the hot loop - if (needsLogging && !successfulSources.empty()) { - #if !USING_FSTREAM_DIRECTIVE - if (!logSource.empty()) { - createDirectory(getParentDirFromPath(logSource)); - if (FILE* logFile = fopen(logSource.c_str(), "a")) { - for (auto it = successfulSources.rbegin(); it != successfulSources.rend(); ++it) { - writeLog(logFile, *it); - } - fclose(logFile); - } - #if USING_LOGGING_DIRECTIVE - else { - if (!disableLogging) - logMessage("Failed to open source log file: " + logSource); - } - #endif - } - - if (!logDestination.empty()) { - createDirectory(getParentDirFromPath(logDestination)); - if (FILE* logFile = fopen(logDestination.c_str(), "a")) { - for (auto it = successfulDestinations.rbegin(); it != successfulDestinations.rend(); ++it) { - writeLog(logFile, *it); - } - fclose(logFile); - } - #if USING_LOGGING_DIRECTIVE - else { - if (!disableLogging) - logMessage("Failed to open destination log file: " + logDestination); - } - #endif - } - #else - if (!logSource.empty()) { - createDirectory(getParentDirFromPath(logSource)); - std::ofstream logSourceFile(logSource, std::ios::app); - if (logSourceFile.is_open()) { - for (auto it = successfulSources.rbegin(); it != successfulSources.rend(); ++it) { - writeLog(logSourceFile, *it); - } - logSourceFile.close(); - } - #if USING_LOGGING_DIRECTIVE - else { - if (!disableLogging) - logMessage("Failed to open source log file: " + logSource); - } - #endif - } - - if (!logDestination.empty()) { - createDirectory(getParentDirFromPath(logDestination)); - std::ofstream logDestFile(logDestination, std::ios::app); - if (logDestFile.is_open()) { - for (auto it = successfulDestinations.rbegin(); it != successfulDestinations.rend(); ++it) { - writeLog(logDestFile, *it); - } - logDestFile.close(); - } - #if USING_LOGGING_DIRECTIVE - else { - if (!disableLogging) - logMessage("Failed to open destination log file: " + logDestination); - } - #endif - } - #endif + // Safely reverse logs now + if (needsLogging) { + if (!logSource.empty()) reverseLogFile(logSource); + if (!logDestination.empty()) reverseLogFile(logDestination); } } + bool moveFile(const std::string& sourcePath, const std::string& destinationPath, @@ -747,7 +778,7 @@ namespace ult { void moveFilesOrDirectoriesByPattern(const std::string& sourcePathPattern, const std::string& destinationPath, const std::string& logSource, const std::string& logDestination) { - std::vector fileList = getFilesListByWildcards(sourcePathPattern); + fileList = getFilesListByWildcards(sourcePathPattern); //std::string fileListAsString; //for (const std::string& filePath : fileList) @@ -763,7 +794,7 @@ namespace ult { // if sourceFile is a file (Needs condition handling) if (!isDirectory(sourceFileOrDirectory)) { //logMessage("destinationPath: "+destinationPath); - moveFileOrDirectory(sourceFileOrDirectory.c_str(), destinationPath.c_str(), logSource, logDestination); + moveFileOrDirectory(sourceFileOrDirectory, destinationPath, logSource, logDestination); } else if (isDirectory(sourceFileOrDirectory)) { // if sourceFile is a directory (needs conditoin handling) folderName = getNameFromPath(sourceFileOrDirectory); @@ -771,11 +802,14 @@ namespace ult { //logMessage("fixedDestinationPath: "+fixedDestinationPath); - moveFileOrDirectory(sourceFileOrDirectory.c_str(), fixedDestinationPath.c_str(), logSource, logDestination); + moveFileOrDirectory(sourceFileOrDirectory, fixedDestinationPath, logSource, logDestination); } sourceFileOrDirectory = ""; } //logMessage("post loop"); + + fileList.clear(); + fileList.shrink_to_fit(); } /** @@ -1244,7 +1278,7 @@ namespace ult { */ void copyFileOrDirectoryByPattern(const std::string& sourcePathPattern, const std::string& toDirectory, const std::string& logSource, const std::string& logDestination) { - std::vector fileList = getFilesListByWildcards(sourcePathPattern); + fileList = getFilesListByWildcards(sourcePathPattern); long long totalSize = 0; for (const std::string& path : fileList) { totalSize += getTotalSize(path); @@ -1255,6 +1289,9 @@ namespace ult { copyFileOrDirectory(sourcePath, toDirectory, &totalBytesCopied, totalSize, logSource, logDestination); sourcePath = ""; } + + fileList.clear(); + fileList.shrink_to_fit(); //copyPercentage.store(-1, std::memory_order_release); // Reset after operation } @@ -1271,7 +1308,7 @@ namespace ult { * Default is "sdmc:/". You can specify a different target path if needed. */ void mirrorFiles(const std::string& sourcePath, const std::string targetPath, const std::string mode) { - std::vector fileList = getFilesListFromDirectory(sourcePath); + fileList = getFilesListFromDirectory(sourcePath); std::string updatedPath; long long totalSize = 0; long long totalBytesCopied = 0; @@ -1298,6 +1335,8 @@ namespace ult { path = ""; } //fileList.clear(); + fileList.clear(); + fileList.shrink_to_fit(); } /** @@ -1312,8 +1351,8 @@ namespace ult { */ void createFlagFiles(const std::string& wildcardPattern, const std::string& outputDir) { // 1) Gather all matches from the wildcard pattern - std::vector allMatches = ult::getFilesListByWildcards(wildcardPattern); - if (allMatches.empty()) { + fileList = ult::getFilesListByWildcards(wildcardPattern); + if (fileList.empty()) { return; // No matches, nothing to do } @@ -1326,7 +1365,7 @@ namespace ult { outputPrefix.push_back('/'); std::string baseName, outFile; - for (auto& fullPath : allMatches) { + for (auto& fullPath : fileList) { baseName = ult::getNameFromPath(fullPath); if (baseName.empty()) { fullPath = ""; @@ -1344,6 +1383,8 @@ namespace ult { #endif fullPath = ""; } + fileList.clear(); + fileList.shrink_to_fit(); } /** diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/string_funcs.cpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/string_funcs.cpp index 8cef0b74..3788eb23 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/string_funcs.cpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/string_funcs.cpp @@ -48,6 +48,27 @@ namespace ult { } + //bool canConvertToInt(const std::string& str) { + // if (str.empty()) { + // return false; + // } + // + // size_t start = 0; + // if (str[0] == '-' || str[0] == '+') { + // if (str.length() == 1) return false; + // start = 1; + // } + // + // for (size_t i = start; i < str.length(); ++i) { + // if (!std::isdigit(static_cast(str[i]))) { + // return false; + // } + // } + // + // return true; + //} + + // Mimics std::getline() with a delimiter bool StringStream::getline(std::string& output, char delimiter) { if (position >= data.size()) { @@ -259,69 +280,62 @@ namespace ult { void preprocessPath(std::string& path, const std::string& packagePath) { removeQuotes(path); - // In-place multiple slash removal - no temporary string creation - if (!path.empty()) { - size_t writePos = 0; - bool previousSlash = false; - - for (size_t i = 0; i < path.length(); ++i) { - if (path[i] == '/') { - if (!previousSlash) { - path[writePos++] = path[i]; - } + if (path.empty()) + return; + + // In-place multiple slash removal + size_t writePos = 0; + bool previousSlash = false; + + for (size_t i = 0, len = path.length(); i < len; ++i) { + const char c = path[i]; + if (c == '/') { + if (!previousSlash) { + path[writePos++] = '/'; previousSlash = true; - } else { - path[writePos++] = path[i]; - previousSlash = false; } + } else { + path[writePos++] = c; + previousSlash = false; } - path.resize(writePos); } + path.resize(writePos); - // First handle "./" replacement if present + // Handle "./" replacement if present if (!packagePath.empty() && path.length() >= 2 && path[0] == '.' && path[1] == '/') { - // Handle "./" - replace with packagePath path.replace(0, 2, packagePath); } - size_t dotDotPos, lastSlash; - std::string beforeDotDot; - - // Then handle any "../" sequences that may exist anywhere in the path - while (!path.empty()) { - dotDotPos = path.find("../"); - if (dotDotPos == std::string::npos) { - break; // No more "../" sequences found + // Handle "../" sequences + size_t dotDotPos; + size_t searchEnd; + while ((dotDotPos = path.find("../")) != std::string::npos) { + // Check if there's a trailing slash before "../" + searchEnd = dotDotPos; + if (searchEnd > 0 && path[searchEnd - 1] == '/') { + --searchEnd; } - // Found "../" sequence at dotDotPos - beforeDotDot = path.substr(0, dotDotPos); + // Find the previous slash + const size_t lastSlash = (searchEnd > 0) ? path.rfind('/', searchEnd - 1) : std::string::npos; - // Remove trailing slash from the part before "../" - if (!beforeDotDot.empty() && beforeDotDot.back() == '/') { - beforeDotDot.pop_back(); - } - - // Go up one level - lastSlash = beforeDotDot.find_last_of('/'); if (lastSlash != std::string::npos) { - beforeDotDot = beforeDotDot.substr(0, lastSlash + 1); + // Erase from after lastSlash to after "../" + path.erase(lastSlash + 1, dotDotPos + 3 - lastSlash - 1); } else { - // No slash found, we're at root level - beforeDotDot = "/"; + // No slash found, replace with root + path.erase(0, dotDotPos); + path.insert(0, "/"); } - - // Replace the path up to and including this "../" with the resolved path - path = beforeDotDot + path.substr(dotDotPos + 3); } - // Direct character comparison instead of substr() for sdmc: prefix + // Check for sdmc: prefix if (path.length() < 5 || path[0] != 's' || path[1] != 'd' || path[2] != 'm' || path[3] != 'c' || path[4] != ':') { path.insert(0, "sdmc:"); } } - + /** * @brief Preprocesses a URL string by adding "https://" prefix. @@ -332,11 +346,16 @@ namespace ult { */ void preprocessUrl(std::string& path) { removeQuotes(path); - if ((path.compare(0, 7, "http://") == 0) || (path.compare(0, 8, "https://") == 0)) { - return; // No need to modify the string if it already has a prefix - } else { - path = "https://" + path; // Prepend "https://" + + if (path.size() >= 7 && path[0] == 'h' && path[1] == 't' && + path[2] == 't' && path[3] == 'p') { + if ((path.size() >= 8 && path[4] == 's' && path[5] == ':') || + (path[4] == ':')) { + return; + } } + + path.insert(0, "https://"); } /** @@ -371,14 +390,22 @@ namespace ult { // Helper function to check if a string is a valid integer bool isValidNumber(const std::string& str) { - if (str.empty() || ((str[0] != '-') && !std::isdigit(str[0])) || (str[0] == '-' && str.size() == 1)) { + if (str.empty()) { return false; } - for (size_t i = 1; i < str.size(); ++i) { - if (!std::isdigit(str[i])) { + + size_t start = 0; + if (str[0] == '-' || str[0] == '+') { + if (str.length() == 1) return false; + start = 1; + } + + for (size_t i = start; i < str.length(); ++i) { + if (!std::isdigit(static_cast(str[i]))) { return false; } } + return true; } diff --git a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/tsl_utils.cpp b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/tsl_utils.cpp index efbdcf7e..3518d190 100644 --- a/Source/sys-clk/overlay/lib/libultrahand/libultra/source/tsl_utils.cpp +++ b/Source/sys-clk/overlay/lib/libultrahand/libultra/source/tsl_utils.cpp @@ -77,6 +77,14 @@ namespace ult { size_t keyStart, keyEnd, colonPos, valueStart, valueEnd; std::string key, value; + auto normalizeNewlines = [](std::string &s) { + size_t n = 0; + while ((n = s.find("\\n", n)) != std::string::npos) { + s.replace(n, 2, "\n"); + n += 1; + } + }; + while ((pos = content.find('"', pos)) != std::string::npos) { keyStart = pos + 1; keyEnd = content.find('"', keyStart); @@ -91,11 +99,16 @@ namespace ult { if (valueStart == std::string::npos || valueEnd == std::string::npos) break; value = content.substr(valueStart + 1, valueEnd - valueStart - 1); + + // 🔹 Convert escaped newlines (\\n) into real ones + normalizeNewlines(key); + normalizeNewlines(value); + result[key] = value; + key.clear(); value.clear(); - - pos = valueEnd + 1; // Move to the next key-value pair + pos = valueEnd + 1; // Move to next pair } } @@ -188,13 +201,60 @@ namespace ult { // snprintf(titleIdStr, sizeof(titleIdStr), "%016lX", tid); // return std::string(titleIdStr); //} + + //std::string getProcessIdAsString() { + // u64 pid = 0; + // if (R_FAILED(pmdmntGetApplicationProcessId(&pid))) + // return NULL_STR; + // + // char pidStr[21]; // Max u64 is 20 digits + null terminator + // snprintf(pidStr, sizeof(pidStr), "%llu", pid); + // return std::string(pidStr); + //} + + std::string getBuildIdAsString() { + u64 pid = 0; + if (R_FAILED(pmdmntGetApplicationProcessId(&pid))) + return NULL_STR; + + Service srv; + if (R_FAILED(smGetService(&srv, "dmnt:cht"))) + return NULL_STR; + + if (R_FAILED(serviceDispatch(&srv, 65003))) { + serviceClose(&srv); + return NULL_STR; + } + + struct { + u64 process_id; + u64 title_id; + struct { u64 base; u64 size; } main_nso_extents; + struct { u64 base; u64 size; } heap_extents; + struct { u64 base; u64 size; } alias_extents; + struct { u64 base; u64 size; } address_space_extents; + u8 main_nso_build_id[0x20]; + } metadata; + + Result rc = serviceDispatchOut(&srv, 65002, metadata); + serviceClose(&srv); + + if (R_FAILED(rc)) + return NULL_STR; + + u64 buildid; + std::memcpy(&buildid, metadata.main_nso_build_id, sizeof(u64)); + + char buildIdStr[17]; + snprintf(buildIdStr, sizeof(buildIdStr), "%016lX", __builtin_bswap64(buildid)); + return std::string(buildIdStr); + } + std::string getTitleIdAsString() { u64 pid = 0, tid = 0; - if (R_FAILED(pmdmntGetApplicationProcessId(&pid))) - return NULL_STR; - - if (R_FAILED(pmdmntGetProgramId(&tid, pid))) + if (R_FAILED(pmdmntGetApplicationProcessId(&pid)) || + R_FAILED(pmdmntGetProgramId(&tid, pid))) return NULL_STR; char tidStr[17]; @@ -215,6 +275,8 @@ namespace ult { bool useSwipeToOpen = true; bool useLaunchCombos = true; bool useNotifications = true; + bool useSoundEffects = true; + bool useHapticFeedback = false; bool usePageSwap = false; bool useDynamicLogo = true; bool useSelectionBG = true; @@ -374,8 +436,9 @@ namespace ult { } - CONSTEXPR_STRING std::string whiteColor = "#FFFFFF"; - CONSTEXPR_STRING std::string blackColor = "#000000"; + CONSTEXPR_STRING std::string whiteColor = "FFFFFF"; + CONSTEXPR_STRING std::string blackColor = "000000"; + CONSTEXPR_STRING std::string greyColor = "AAAAAA"; std::atomic languageWasChanged{false}; @@ -470,6 +533,8 @@ namespace ult { std::string FAILED_TO_OPEN = "Failed to open file"; std::string LAUNCH_COMBOS = "Launch Combos"; std::string NOTIFICATIONS = "Notifications"; + std::string SOUND_EFFECTS = "Sound Effects"; + std::string HAPTIC_FEEDBACK = "Haptic Feedback"; std::string OPAQUE_SCREENSHOTS = "Opaque Screenshots"; std::string PACKAGE_INFO = "Package Info"; @@ -678,6 +743,8 @@ namespace ult { LAUNCH_COMBOS = "Launch Combos"; NOTIFICATIONS = "Notifications"; + SOUND_EFFECTS = "Sound Effects"; + HAPTIC_FEEDBACK = "Haptic Feedback"; OPAQUE_SCREENSHOTS = "Opaque Screenshots"; ON = "On"; OFF = "Off"; @@ -886,6 +953,8 @@ namespace ult { {"LAUNCH_COMBOS", &LAUNCH_COMBOS}, {"NOTIFICATIONS", &NOTIFICATIONS}, + {"SOUND_EFFECTS", &SOUND_EFFECTS}, + {"HAPTIC_FEEDBACK", &HAPTIC_FEEDBACK}, {"OPAQUE_SCREENSHOTS", &OPAQUE_SCREENSHOTS}, {"PACKAGE_INFO", &PACKAGE_INFO}, @@ -1143,6 +1212,7 @@ namespace ult { {"separator_color", "404040"}, {"text_separator_color", "404040"}, {"text_color", whiteColor}, + {"notification_text_color", whiteColor}, {"header_text_color", whiteColor}, {"header_separator_color", whiteColor}, {"star_color", whiteColor}, @@ -1169,13 +1239,13 @@ namespace ult { {"ult_overlay_text_color", "9ed0ff"}, {"package_text_color", whiteColor}, {"ult_package_text_color", "9ed0ff"}, - {"banner_version_text_color", "AAAAAA"}, - {"overlay_version_text_color", "AAAAAA"}, + {"banner_version_text_color", greyColor}, + {"overlay_version_text_color", greyColor}, {"ult_overlay_version_text_color", "00FFDD"}, - {"package_version_text_color", "AAAAAA"}, + {"package_version_text_color", greyColor}, {"ult_package_version_text_color", "00FFDD"}, {"on_text_color", "00FFDD"}, - {"off_text_color", "AAAAAA"}, + {"off_text_color", greyColor}, {"invalid_text_color", "FF0000"}, {"inprogress_text_color", "FFFF45"}, {"selection_text_color", "9ed0ff"}, @@ -1239,7 +1309,7 @@ namespace ult { } - + std::atomic refreshWallpaperNow(false); std::atomic refreshWallpaper(false); std::vector wallpaperData; std::atomic inPlot(false); @@ -1249,10 +1319,128 @@ namespace ult { // Function to load the RGBA file into memory and modify wallpaperData directly + //void loadWallpaperFile(const std::string& filePath, s32 width, s32 height) { + // const size_t originalDataSize = width * height * 4; // Original size in bytes (4 bytes per pixel) + // const size_t compressedDataSize = originalDataSize / 2; // RGBA4444 uses half the space + // + // wallpaperData.resize(compressedDataSize); + // + // if (!isFileOrDirectory(filePath)) { + // wallpaperData.clear(); + // return; + // } + // + // #if !USING_FSTREAM_DIRECTIVE + // FILE* file = fopen(filePath.c_str(), "rb"); + // if (!file) { + // wallpaperData.clear(); + // return; + // } + // + // std::vector buffer; + // //if (reducedMemory) { + // // // Reuse wallpaperData to avoid double allocation + // // buffer.swap(wallpaperData); + // // buffer.resize(originalDataSize); + // //} else { + // buffer.resize(originalDataSize); + // //} + // + // const size_t bytesRead = fread(buffer.data(), 1, originalDataSize, file); + // fclose(file); + // + // if (bytesRead != originalDataSize) { + // wallpaperData.clear(); + // return; + // } + // + // #else + // std::ifstream file(filePath, std::ios::binary); + // if (!file) { + // wallpaperData.clear(); + // return; + // } + // + // std::vector buffer; + // //if (reducedMemory) { + // // buffer.swap(wallpaperData); + // // buffer.resize(originalDataSize); + // //} else { + // buffer.resize(originalDataSize); + // //} + // + // file.read(reinterpret_cast(buffer.data()), originalDataSize); + // if (!file) { + // wallpaperData.clear(); + // return; + // } + // #endif + // + // // Compress RGBA8888 to RGBA4444 + // //if (reducedMemory) { + // // // In-place compression to save memory + // // size_t writeIndex = 0; + // // for (size_t i = 0; i < originalDataSize; i += 8, writeIndex += 4) { + // // uint8_t r1 = buffer[i] >> 4; + // // uint8_t g1 = buffer[i + 1] >> 4; + // // uint8_t b1 = buffer[i + 2] >> 4; + // // uint8_t a1 = buffer[i + 3] >> 4; + // // + // // uint8_t r2 = buffer[i + 4] >> 4; + // // uint8_t g2 = buffer[i + 5] >> 4; + // // uint8_t b2 = buffer[i + 6] >> 4; + // // uint8_t a2 = buffer[i + 7] >> 4; + // // + // // buffer[writeIndex] = (r1 << 4) | g1; + // // buffer[writeIndex + 1] = (b1 << 4) | a1; + // // buffer[writeIndex + 2] = (r2 << 4) | g2; + // // buffer[writeIndex + 3] = (b2 << 4) | a2; + // // } + // // buffer.resize(compressedDataSize); + // // wallpaperData.swap(buffer); + // //} else { + // uint8_t* input = buffer.data(); + // uint8_t* output = wallpaperData.data(); + // //uint8_t r1, g1, b1, a1; + // //uint8_t r2, g2, b2, a2; + // + // //for (size_t i = 0, j = 0; i < originalDataSize; i += 8, j += 4) { + // // // Read 2 RGBA pixels (8 bytes) + // // const uint8_t r1 = input[i] >> 4; + // // const uint8_t g1 = input[i + 1] >> 4; + // // const uint8_t b1 = input[i + 2] >> 4; + // // const uint8_t a1 = input[i + 3] >> 4; + // // + // // const uint8_t r2 = input[i + 4] >> 4; + // // const uint8_t g2 = input[i + 5] >> 4; + // // const uint8_t b2 = input[i + 6] >> 4; + // // const uint8_t a2 = input[i + 7] >> 4; + // // + // // // Pack them into 4 bytes (2 bytes per pixel) + // // output[j] = (r1 << 4) | g1; + // // output[j + 1] = (b1 << 4) | a1; + // // output[j + 2] = (r2 << 4) | g2; + // // output[j + 3] = (b2 << 4) | a2; + // //} + // + // for (size_t i = 0, j = 0; i < originalDataSize; i += 16, j += 8) { + // output[j] = ((input[i] >> 4) << 4) | (input[i + 1] >> 4); + // output[j + 1] = ((input[i + 2] >> 4) << 4) | (input[i + 3] >> 4); + // output[j + 2] = ((input[i + 4] >> 4) << 4) | (input[i + 5] >> 4); + // output[j + 3] = ((input[i + 6] >> 4) << 4) | (input[i + 7] >> 4); + // output[j + 4] = ((input[i + 8] >> 4) << 4) | (input[i + 9] >> 4); + // output[j + 5] = ((input[i + 10] >> 4) << 4) | (input[i + 11] >> 4); + // output[j + 6] = ((input[i + 12] >> 4) << 4) | (input[i + 13] >> 4); + // output[j + 7] = ((input[i + 14] >> 4) << 4) | (input[i + 15] >> 4); + // } + // //} + //} + + void loadWallpaperFile(const std::string& filePath, s32 width, s32 height) { - const size_t originalDataSize = width * height * 4; // Original size in bytes (4 bytes per pixel) - const size_t compressedDataSize = originalDataSize / 2; // RGBA4444 uses half the space - + const size_t originalDataSize = width * height * 4; + const size_t compressedDataSize = originalDataSize / 2; + wallpaperData.resize(compressedDataSize); if (!isFileOrDirectory(filePath)) { @@ -1260,61 +1448,44 @@ namespace ult { return; } - #if !USING_FSTREAM_DIRECTIVE - FILE* file = fopen(filePath.c_str(), "rb"); - if (!file) { - wallpaperData.clear(); - return; - } - - std::vector buffer(originalDataSize); - const size_t bytesRead = fread(buffer.data(), 1, originalDataSize, file); - fclose(file); - - if (bytesRead != originalDataSize) { - wallpaperData.clear(); - return; - } - - #else - std::ifstream file(filePath, std::ios::binary); - if (!file) { - wallpaperData.clear(); - return; - } - - std::vector buffer(originalDataSize); - file.read(reinterpret_cast(buffer.data()), originalDataSize); - if (!file) { - wallpaperData.clear(); - return; - } - #endif - - // Compress RGBA8888 to RGBA4444 - uint8_t* input = buffer.data(); - uint8_t* output = wallpaperData.data(); - uint8_t r1, g1, b1, a1; - uint8_t r2, g2, b2, a2; - - for (size_t i = 0, j = 0; i < originalDataSize; i += 8, j += 4) { - // Read 2 RGBA pixels (8 bytes) - r1 = input[i] >> 4; - g1 = input[i + 1] >> 4; - b1 = input[i + 2] >> 4; - a1 = input[i + 3] >> 4; - - r2 = input[i + 4] >> 4; - g2 = input[i + 5] >> 4; - b2 = input[i + 6] >> 4; - a2 = input[i + 7] >> 4; - - // Pack them into 4 bytes (2 bytes per pixel) - output[j] = (r1 << 4) | g1; - output[j + 1] = (b1 << 4) | a1; - output[j + 2] = (r2 << 4) | g2; - output[j + 3] = (b2 << 4) | a2; + FILE* file = fopen(filePath.c_str(), "rb"); + if (!file) { + wallpaperData.clear(); + return; } + + constexpr size_t chunkBytes = 64 * 1024; // 64 KB chunks + uint8_t chunkBuffer[chunkBytes]; + + size_t totalRead = 0; + size_t writeIndex = 0; + + size_t remaining, toRead, bytesRead; + + while (totalRead < originalDataSize) { + // Determine how much to read this iteration + remaining = originalDataSize - totalRead; + toRead = remaining < chunkBytes ? remaining : chunkBytes; + + bytesRead = fread(chunkBuffer, 1, toRead, file); + if (bytesRead == 0 || bytesRead % 8 != 0) { // must be multiple of 2 pixels + fclose(file); + wallpaperData.clear(); + return; + } + + // Compress each 2-pixel group in the chunk + for (size_t i = 0; i < bytesRead; i += 8, writeIndex += 4) { + wallpaperData[writeIndex] = (chunkBuffer[i] & 0xF0) | (chunkBuffer[i + 1] >> 4); + wallpaperData[writeIndex + 1] = (chunkBuffer[i + 2] & 0xF0) | (chunkBuffer[i + 3] >> 4); + wallpaperData[writeIndex + 2] = (chunkBuffer[i + 4] & 0xF0) | (chunkBuffer[i + 5] >> 4); + wallpaperData[writeIndex + 3] = (chunkBuffer[i + 6] & 0xF0) | (chunkBuffer[i + 7] >> 4); + } + + totalRead += bytesRead; + } + + fclose(file); } diff --git a/Source/sys-clk/overlay/src/ipc.h b/Source/sys-clk/overlay/src/ipc.h index 282cc427..f343d72f 100644 --- a/Source/sys-clk/overlay/src/ipc.h +++ b/Source/sys-clk/overlay/src/ipc.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #if defined(__cplusplus) diff --git a/Source/sys-clk/overlay/src/main.cpp b/Source/sys-clk/overlay/src/main.cpp index 03c69f35..f2085057 100644 --- a/Source/sys-clk/overlay/src/main.cpp +++ b/Source/sys-clk/overlay/src/main.cpp @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #define TESLA_INIT_IMPL #include @@ -40,7 +57,7 @@ class AppOverlay : public tsl::Overlay if(!sysclkIpcRunning()) { return initially( - "sys-clk is not running.\n\n" + "Horizon OC is not running.\n\n" "\n" "Please make sure it is correctly\n\n" "installed and enabled.", @@ -51,7 +68,7 @@ class AppOverlay : public tsl::Overlay if(R_FAILED(sysclkIpcInitialize()) || R_FAILED(sysclkIpcGetAPIVersion(&apiVersion))) { return initially( - "Could not connect to sys-clk.\n\n" + "Could not connect to Horizon OC.\n\n" "\n" "Please make sure it is correctly\n\n" "installed and enabled.", @@ -63,7 +80,7 @@ class AppOverlay : public tsl::Overlay { return initially( "Overlay not compatible with\n\n" - "the running sys-clk version.\n\n" + "the running Horizon OC version.\n\n" "\n" "Please make sure everything is\n\n" "installed and up to date.", diff --git a/Source/sys-clk/overlay/src/ui/elements/base_frame.h b/Source/sys-clk/overlay/src/ui/elements/base_frame.h index 053ef26a..1828de70 100644 --- a/Source/sys-clk/overlay/src/ui/elements/base_frame.h +++ b/Source/sys-clk/overlay/src/ui/elements/base_frame.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include diff --git a/Source/sys-clk/overlay/src/ui/format.h b/Source/sys-clk/overlay/src/ui/format.h index e20c5b5b..e09cd431 100644 --- a/Source/sys-clk/overlay/src/ui/format.h +++ b/Source/sys-clk/overlay/src/ui/format.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,11 +24,12 @@ * -------------------------------------------------------------------------- */ + #pragma once #include -#define FREQ_DEFAULT_TEXT "Do not override" +#define FREQ_DEFAULT_TEXT "Default" static inline std::string formatListFreqMHz(std::uint32_t mhz) { diff --git a/Source/sys-clk/overlay/src/ui/gui/app_profile_gui.cpp b/Source/sys-clk/overlay/src/ui/gui/app_profile_gui.cpp index cac497f9..2f68228e 100644 --- a/Source/sys-clk/overlay/src/ui/gui/app_profile_gui.cpp +++ b/Source/sys-clk/overlay/src/ui/gui/app_profile_gui.cpp @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #include "app_profile_gui.h" #include "../format.h" @@ -46,7 +63,8 @@ void AppProfileGui::openFreqChoiceGui(tsl::elm::ListItem* listItem, SysClkProfil } return true; - }); + }, true + ); } void AppProfileGui::addModuleListItem(SysClkProfile profile, SysClkModule module) @@ -61,7 +79,7 @@ void AppProfileGui::addModuleListItem(SysClkProfile profile, SysClkModule module } else if((keys & HidNpadButton_Y) == HidNpadButton_Y) { - // Reset to "Do not override" (0 MHz) + // Reset to "Default" (0 MHz) this->profileList->mhzMap[profile][module] = 0; listItem->setValue(formatListFreqMHz(0)); diff --git a/Source/sys-clk/overlay/src/ui/gui/app_profile_gui.h b/Source/sys-clk/overlay/src/ui/gui/app_profile_gui.h index 5e1ecc6d..5cf87d9c 100644 --- a/Source/sys-clk/overlay/src/ui/gui/app_profile_gui.h +++ b/Source/sys-clk/overlay/src/ui/gui/app_profile_gui.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include "../../ipc.h" diff --git a/Source/sys-clk/overlay/src/ui/gui/base_gui.cpp b/Source/sys-clk/overlay/src/ui/gui/base_gui.cpp index d32986b2..8513d2e2 100644 --- a/Source/sys-clk/overlay/src/ui/gui/base_gui.cpp +++ b/Source/sys-clk/overlay/src/ui/gui/base_gui.cpp @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -13,31 +29,119 @@ #include "../elements/base_frame.h" #include "logo_rgba_bin.h" +#include +#include - +// ------------------------------------------------------------- +// Layout constants +// ------------------------------------------------------------- #define LOGO_X 20 -#define LOGO_Y 45 -#define LOGO_LABEL_FONT_SIZE 35 +#define LOGO_Y 50 +#define LOGO_LABEL_FONT_SIZE 45 #define VERSION_X (LOGO_X + 250) -#define VERSION_Y LOGO_Y-40 +#define VERSION_Y (LOGO_Y - 40) #define VERSION_FONT_SIZE 15 +// ------------------------------------------------------------- +// Version string getter +// ------------------------------------------------------------- + std::string getVersionString() { - char buf[0x100] = ""; // 256 bytes — safe for any expected version string + char buf[0x100] = ""; Result rc = sysclkIpcGetVersionString(buf, sizeof(buf)); if (R_FAILED(rc) || buf[0] == '\0') { - return "unknown"; + return "HorizonOC-Misc"; } return std::string(buf); } +// ------------------------------------------------------------- +// Animated Ultra Text +// ------------------------------------------------------------- + +// Your animated wave colors (example placeholders) +static constexpr tsl::Color dynamicLogoRGB1 = tsl::Color(40, 255, 80, 255); +static constexpr tsl::Color dynamicLogoRGB2 = tsl::Color(120, 255, 160, 255); + +// Your project name rendered letter-by-letter +static constexpr const char* PROJECT_NAME = "Horizon OC Gaea"; + +// Fully corrected function signature +static s32 drawDynamicUltraText( + tsl::gfx::Renderer* renderer, + s32 startX, + s32 y, + u32 fontSize, + const tsl::Color& staticColor, + bool useNotificationMethod = false) +{ + static constexpr double cycleDuration = 1.6; + + const std::string name = "Horizon OC Gaea"; + s32 currentX = startX; + + const u64 currentTime_ns = armTicksToNs(armGetSystemTick()); + const double timeNow = static_cast(currentTime_ns) / 1e9; + const double timeBase = fmod(timeNow, cycleDuration); + + // Controls wave spacing + const double waveScale = 2.0 * M_PI / cycleDuration; + + // Every character has its own index offset + for (size_t i = 0; i < name.size(); i++) + { + char letter = name[i]; + if (letter == '\0') break; + + // phase shift per character → THIS CREATES THE WAVE + double phase = waveScale * (timeBase + i * 0.12); + + double raw = cos(phase); + double n = (raw + 1.0) * 0.5; + + // Smoothstep ×2 (ultra smooth) + double s1 = n * n * (3.0 - 2.0 * n); + double s2 = s1 * s1 * (3.0 - 2.0 * s1); + + double blend = std::clamp(s2, 0.0, 1.0); + + tsl::Color color = { + static_cast(staticColor.r + (dynamicLogoRGB2.r - staticColor.r) * blend), + static_cast(staticColor.g + (dynamicLogoRGB2.g - staticColor.g) * blend), + static_cast(staticColor.b + (dynamicLogoRGB2.b - staticColor.b) * blend), + 255 + }; + + std::string ls(1, letter); + + if (useNotificationMethod) + currentX += renderer->drawNotificationString(ls, false, currentX, y, fontSize, color).first; + else + currentX += renderer->drawString(ls, false, currentX, y, fontSize, color).first; + } + + return currentX; +} + + +// ------------------------------------------------------------- +// Rendering functions +// ------------------------------------------------------------- + void BaseGui::preDraw(tsl::gfx::Renderer* renderer) { -// renderer->drawBitmap(LOGO_X, LOGO_Y, LOGO_WIDTH, LOGO_HEIGHT, logo_rgba_bin); - renderer->drawString("Horizon OC overlay", false, LOGO_X, LOGO_Y, LOGO_LABEL_FONT_SIZE, renderer->a(TEXT_COLOR)); -// renderer->drawString(TARGET_VERSION, false, VERSION_X, VERSION_Y, VERSION_FONT_SIZE, tsl::bannerVersionTextColor); + static constexpr tsl::Color STATIC_GREEN = tsl::Color(80, 255, 120, 255); + + drawDynamicUltraText( + renderer, + LOGO_X, + LOGO_Y, + LOGO_LABEL_FONT_SIZE, + STATIC_GREEN, + false + ); } tsl::elm::Element* BaseGui::createUI() diff --git a/Source/sys-clk/overlay/src/ui/gui/base_gui.h b/Source/sys-clk/overlay/src/ui/gui/base_gui.h index a3a7f8cc..eac03aee 100644 --- a/Source/sys-clk/overlay/src/ui/gui/base_gui.h +++ b/Source/sys-clk/overlay/src/ui/gui/base_gui.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include diff --git a/Source/sys-clk/overlay/src/ui/gui/base_menu_gui.cpp b/Source/sys-clk/overlay/src/ui/gui/base_menu_gui.cpp index f999b7a1..21f3e0bb 100644 --- a/Source/sys-clk/overlay/src/ui/gui/base_menu_gui.cpp +++ b/Source/sys-clk/overlay/src/ui/gui/base_menu_gui.cpp @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #include "base_menu_gui.h" #include "fatal_gui.h" diff --git a/Source/sys-clk/overlay/src/ui/gui/base_menu_gui.h b/Source/sys-clk/overlay/src/ui/gui/base_menu_gui.h index d9c061ea..22a76c2a 100644 --- a/Source/sys-clk/overlay/src/ui/gui/base_menu_gui.h +++ b/Source/sys-clk/overlay/src/ui/gui/base_menu_gui.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include "../../rgltr_services.h" diff --git a/Source/sys-clk/overlay/src/ui/gui/fatal_gui.cpp b/Source/sys-clk/overlay/src/ui/gui/fatal_gui.cpp index a1f225a0..e2ce452e 100644 --- a/Source/sys-clk/overlay/src/ui/gui/fatal_gui.cpp +++ b/Source/sys-clk/overlay/src/ui/gui/fatal_gui.cpp @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #include "fatal_gui.h" FatalGui::FatalGui(const std::string message, const std::string info) diff --git a/Source/sys-clk/overlay/src/ui/gui/fatal_gui.h b/Source/sys-clk/overlay/src/ui/gui/fatal_gui.h index e20b6cc9..0c5c3784 100644 --- a/Source/sys-clk/overlay/src/ui/gui/fatal_gui.h +++ b/Source/sys-clk/overlay/src/ui/gui/fatal_gui.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include diff --git a/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.cpp b/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.cpp index c768a969..79b6418b 100644 --- a/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.cpp +++ b/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.cpp @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,124 +24,185 @@ * -------------------------------------------------------------------------- */ - #include "freq_choice_gui.h" - #include "../format.h" - #include "fatal_gui.h" - - FreqChoiceGui::FreqChoiceGui(std::uint32_t selectedHz, std::uint32_t *hzList, std::uint32_t hzCount, SysClkModule module, FreqChoiceListener listener) - { - this->selectedHz = selectedHz; - this->hzList = hzList; - this->hzCount = hzCount; - this->module = module; // Add this - this->listener = listener; - } - - tsl::elm::ListItem* FreqChoiceGui::createFreqListItem(std::uint32_t hz, bool selected, int safety) - { - std::string text = formatListFreqHz(hz); - if (selected) text += " \uE14B"; - - tsl::elm::ListItem* listItem = new tsl::elm::ListItem(text, "", false); - - switch (safety) - { - case 0: - listItem->setTextColor(tsl::Color(255, 255, 255, 255)); - listItem->setValueColor(tsl::Color(255, 255, 255, 255)); - break; - case 1: - listItem->setTextColor(tsl::Color(255, 165, 0, 255)); - listItem->setValueColor(tsl::Color(255, 165, 0, 255)); - break; - case 2: - listItem->setTextColor(tsl::Color(255, 0, 0, 255)); - listItem->setValueColor(tsl::Color(255, 0, 0, 255)); - break; - } - - listItem->setClickListener([this, hz](u64 keys) - { - if ((keys & HidNpadButton_A) == HidNpadButton_A && this->listener) { - if (this->listener(hz)) { - tsl::goBack(); - } - return true; - } - return false; - }); - - return listItem; - } - - void FreqChoiceGui::listUI() - { - // Add CategoryHeader based on module - std::string moduleName = sysclkFormatModule(this->module, false); - this->listElement->addItem(new tsl::elm::CategoryHeader(moduleName)); - - this->listElement->addItem(this->createFreqListItem(0, this->selectedHz == 0, false)); - std::uint32_t hz; - for (std::uint32_t i = 0; i < this->hzCount; i++) - { - hz = this->hzList[i]; - uint32_t mhz = hz / 1000000; - // Skip 204 MHz exactly - if (moduleName == "mem" && mhz <= 600) - { - continue; - } - uint32_t unsafe_cpu; - uint32_t unsafe_gpu; - uint32_t danger_cpu; - uint32_t danger_gpu; - if (IsMariko()) - { - unsafe_cpu = 1964; - unsafe_gpu = 1153; - danger_cpu = 2398; - danger_gpu = 1306; - } - else - { - unsafe_cpu = 1786; - unsafe_gpu = 922; - danger_cpu = 2092; - danger_gpu = 999; - } +#include "freq_choice_gui.h" - if (moduleName == "cpu") { - if (mhz >= danger_cpu) { - this->listElement->addItem(this->createFreqListItem(hz, mhz == this->selectedHz / 1000000, 2)); - continue; - } - if (mhz >= unsafe_cpu) { - this->listElement->addItem(this->createFreqListItem(hz, mhz == this->selectedHz / 1000000, 1)); - continue; - } - if (mhz <= unsafe_cpu) { - this->listElement->addItem(this->createFreqListItem(hz, mhz == this->selectedHz / 1000000, 0)); +#include "../format.h" +#include "fatal_gui.h" + +FreqChoiceGui::FreqChoiceGui(std::uint32_t selectedHz, + std::uint32_t* hzList, + std::uint32_t hzCount, + SysClkModule module, + FreqChoiceListener listener, + bool checkMax, + std::map labels) +{ + this->selectedHz = selectedHz; + this->hzList = hzList; + this->hzCount = hzCount; + this->module = module; + this->listener = listener; + this->checkMax = checkMax; + this->labels = labels; // NEW + this->configList = new SysClkConfigValueList {}; +} + +FreqChoiceGui::~FreqChoiceGui() +{ + delete this->configList; +} + +tsl::elm::ListItem* FreqChoiceGui::createFreqListItem(std::uint32_t hz, bool selected, int safety) +{ + std::string text = formatListFreqHz(hz); + if (selected) + text += " \uE14B"; + + // NEW: Right-side label + std::string rightText = ""; + auto it = labels.find(hz); + if (it != labels.end()) + rightText = it->second; + + tsl::elm::ListItem* listItem = + new tsl::elm::ListItem(text, rightText, false); + + switch (safety) + { + case 0: + listItem->setTextColor(tsl::Color(255, 255, 255, 255)); + listItem->setValueColor(tsl::Color(255, 255, 255, 255)); + break; + case 1: + listItem->setTextColor(tsl::Color(255, 165, 0, 255)); + listItem->setValueColor(tsl::Color(255, 165, 0, 255)); + break; + case 2: + listItem->setTextColor(tsl::Color(255, 0, 0, 255)); + listItem->setValueColor(tsl::Color(255, 0, 0, 255)); + break; + } + + // Make annotation grey + if (!rightText.empty()) + listItem->setValueColor(tsl::Color(180, 180, 180, 255)); + + listItem->setClickListener([this, hz](u64 keys) + { + if ((keys & HidNpadButton_A) == HidNpadButton_A && this->listener) { + if (this->listener(hz)) { + tsl::goBack(); + } + return true; + } + return false; + }); + + return listItem; +} + +void FreqChoiceGui::listUI() +{ + sysclkIpcGetConfigValues(this->configList); + + // Header based on CPU/GPU/MEM module + std::string moduleName = sysclkFormatModule(this->module, false); + this->listElement->addItem(new tsl::elm::CategoryHeader(moduleName)); + + // Default option + this->listElement->addItem( + this->createFreqListItem(0, this->selectedHz == 0, 0)); + + for (std::uint32_t i = 0; i < this->hzCount; i++) + { + std::uint32_t hz = this->hzList[i]; + uint32_t mhz = hz / 1000000; + + if (checkMax && IsMariko()) { + if (moduleName == "cpu" && + this->configList->values[HocClkConfigValue_MarikoMaxCpuClock] < mhz) continue; - } - } else if (moduleName == "gpu") { - if (mhz >= danger_gpu) { - this->listElement->addItem(this->createFreqListItem(hz, mhz == this->selectedHz / 1000000, 2)); - continue; - } - if (mhz >= unsafe_gpu) { - this->listElement->addItem(this->createFreqListItem(hz, mhz == this->selectedHz / 1000000, 1)); - continue; - } - if (mhz <= unsafe_gpu) { - this->listElement->addItem(this->createFreqListItem(hz, mhz == this->selectedHz / 1000000, 0)); + + if (moduleName == "gpu" && + this->configList->values[HocClkConfigValue_MarikoMaxGpuClock] < mhz) continue; - } - } else if (moduleName == "mem") { - this->listElement->addItem(this->createFreqListItem(hz, mhz == this->selectedHz / 1000000, 0)); + + if (moduleName == "mem" && + this->configList->values[HocClkConfigValue_MarikoMaxMemClock] < mhz) + continue; + + } else if (checkMax && IsErista()) { + if (moduleName == "cpu" && + this->configList->values[HocClkConfigValue_EristaMaxCpuClock] < mhz) + continue; + + if (moduleName == "gpu" && + this->configList->values[HocClkConfigValue_EristaMaxGpuClock] < mhz) + continue; + + if (moduleName == "mem" && + this->configList->values[HocClkConfigValue_EristaMaxMemClock] < mhz) + continue; + } + + if (moduleName == "mem" && mhz <= 600) continue; - } - - } - this->listElement->jumpToItem("", ""); - } \ No newline at end of file + + uint32_t unsafe_cpu; + uint32_t unsafe_gpu; + uint32_t danger_cpu; + uint32_t danger_gpu; + + if (IsMariko()) + { + unsafe_cpu = 1964; + unsafe_gpu = 1076; + danger_cpu = 2398; + danger_gpu = 1306; + } + else + { + unsafe_cpu = 1786; + unsafe_gpu = 922; + danger_cpu = 2092; + danger_gpu = 999; + } + + int safety = 0; + + if (moduleName == "cpu") { + + if (mhz >= danger_cpu) + safety = 2; + else if (mhz >= unsafe_cpu) + safety = 1; + else + safety = 0; + + } else if (moduleName == "gpu") { + + if (mhz >= danger_gpu) + safety = 2; + else if (mhz >= unsafe_gpu) + safety = 1; + else + safety = 0; + + } else if (moduleName == "mem") { + + safety = 0; + + } + + this->listElement->addItem( + this->createFreqListItem( + hz, + (mhz == this->selectedHz / 1000000), + safety + ) + ); + } + + this->listElement->jumpToItem("", ""); +} \ No newline at end of file diff --git a/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.h b/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.h index 5458af96..cf18095c 100644 --- a/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.h +++ b/Source/sys-clk/overlay/src/ui/gui/freq_choice_gui.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,28 +24,44 @@ * -------------------------------------------------------------------------- */ + #pragma once #include - +#include +#include #include "base_menu_gui.h" using FreqChoiceListener = std::function; -#define FREQ_DEFAULT_TEXT "Do not override" +#define FREQ_DEFAULT_TEXT "Default" class FreqChoiceGui : public BaseMenuGui { - protected: - std::uint32_t selectedHz; - std::uint32_t* hzList; - std::uint32_t hzCount; - SysClkModule module; // Added - FreqChoiceListener listener; - tsl::elm::ListItem* createFreqListItem(std::uint32_t hz, bool selected, int safety); +protected: + SysClkConfigValueList* configList; + std::uint32_t selectedHz; + std::uint32_t* hzList; + std::uint32_t hzCount; + SysClkModule module; + FreqChoiceListener listener; + bool checkMax; - public: - FreqChoiceGui(std::uint32_t selectedHz, std::uint32_t* hzList, std::uint32_t hzCount, SysClkModule module, FreqChoiceListener listener); - ~FreqChoiceGui() {} - void listUI() override; + // NEW: Optional annotation labels + std::map labels; + + tsl::elm::ListItem* createFreqListItem(std::uint32_t hz, bool selected, int safety); + +public: + FreqChoiceGui(std::uint32_t selectedHz, + std::uint32_t* hzList, + std::uint32_t hzCount, + SysClkModule module, + FreqChoiceListener listener, + bool checkMax = true, + std::map labels = {}); // NEW ARG + + ~FreqChoiceGui(); + + void listUI() override; }; diff --git a/Source/sys-clk/overlay/src/ui/gui/global_override_gui.cpp b/Source/sys-clk/overlay/src/ui/gui/global_override_gui.cpp index 97104411..eac22cee 100644 --- a/Source/sys-clk/overlay/src/ui/gui/global_override_gui.cpp +++ b/Source/sys-clk/overlay/src/ui/gui/global_override_gui.cpp @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #include "global_override_gui.h" #include "fatal_gui.h" @@ -44,7 +61,7 @@ void GlobalOverrideGui::openFreqChoiceGui(SysClkModule module) this->context->overrideFreqs[module] = hz; return true; - }); + }, true); } void GlobalOverrideGui::addModuleListItem(SysClkModule module) @@ -59,7 +76,7 @@ void GlobalOverrideGui::addModuleListItem(SysClkModule module) } else if((keys & HidNpadButton_Y) == HidNpadButton_Y) { - // Reset override to "Do not override" (0 Hz) + // Reset override to "Default" (0 Hz) Result rc = sysclkIpcSetOverride(module, 0); if(R_FAILED(rc)) { diff --git a/Source/sys-clk/overlay/src/ui/gui/global_override_gui.h b/Source/sys-clk/overlay/src/ui/gui/global_override_gui.h index 3dc9caf5..477ff7cc 100644 --- a/Source/sys-clk/overlay/src/ui/gui/global_override_gui.h +++ b/Source/sys-clk/overlay/src/ui/gui/global_override_gui.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include "../../ipc.h" diff --git a/Source/sys-clk/overlay/src/ui/gui/main_gui.cpp b/Source/sys-clk/overlay/src/ui/gui/main_gui.cpp index 9fd8e11b..d8c29923 100644 --- a/Source/sys-clk/overlay/src/ui/gui/main_gui.cpp +++ b/Source/sys-clk/overlay/src/ui/gui/main_gui.cpp @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #include "main_gui.h" #include "fatal_gui.h" diff --git a/Source/sys-clk/overlay/src/ui/gui/main_gui.h b/Source/sys-clk/overlay/src/ui/gui/main_gui.h index ea54ef53..77b98a2e 100644 --- a/Source/sys-clk/overlay/src/ui/gui/main_gui.h +++ b/Source/sys-clk/overlay/src/ui/gui/main_gui.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include "base_menu_gui.h" diff --git a/Source/sys-clk/overlay/src/ui/gui/misc_gui.cpp b/Source/sys-clk/overlay/src/ui/gui/misc_gui.cpp index 54ed48ac..3aacd96d 100644 --- a/Source/sys-clk/overlay/src/ui/gui/misc_gui.cpp +++ b/Source/sys-clk/overlay/src/ui/gui/misc_gui.cpp @@ -1,9 +1,31 @@ +/* + * Copyright (C) Switch-OC-Suite + * + * Copyright (c) 2023 hanai3Bi + * + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + + #include "misc_gui.h" #include "fatal_gui.h" #include "../format.h" #include #include -//#include +#include MiscGui::MiscGui() { @@ -14,9 +36,12 @@ MiscGui::~MiscGui() { delete this->configList; this->configToggles.clear(); + this->configTrackbars.clear(); + this->configButtons.clear(); + this->configRanges.clear(); } -void MiscGui::addConfigToggle(SysClkConfigValue configVal, const char* altName = nullptr) { +void MiscGui::addConfigToggle(SysClkConfigValue configVal, const char* altName) { const char* configName = altName ? altName : sysclkFormatConfigValue(configVal, true); tsl::elm::ToggleListItem* toggle = new tsl::elm::ToggleListItem(configName, this->configList->values[configVal]); toggle->setStateChangedListener([this, configVal](bool state) { @@ -24,13 +49,160 @@ void MiscGui::addConfigToggle(SysClkConfigValue configVal, const char* altName = Result rc = sysclkIpcSetConfigValues(this->configList); if (R_FAILED(rc)) FatalGui::openWithResultCode("sysclkIpcSetConfigValues", rc); - this->lastContextUpdate = armGetSystemTick(); }); this->listElement->addItem(toggle); this->configToggles[configVal] = toggle; } +void MiscGui::addConfigButton(SysClkConfigValue configVal, + const char* altName, + const ValueRange& range, + const std::string& categoryName, + const ValueThresholds* thresholds, + const std::map& labels) +{ + const char* configName = altName ? altName : sysclkFormatConfigValue(configVal, true); + + tsl::elm::ListItem* listItem = new tsl::elm::ListItem(configName); + + uint64_t currentValue = this->configList->values[configVal]; + char valueText[32]; + if (currentValue == 0) { + snprintf(valueText, sizeof(valueText), "%s", VALUE_DEFAULT_TEXT); + } else { + uint64_t displayValue = currentValue / range.divisor; + if (!range.suffix.empty()) { + snprintf(valueText, sizeof(valueText), "%lu %s", displayValue, range.suffix.c_str()); + } else { + snprintf(valueText, sizeof(valueText), "%lu", displayValue); + } + } + listItem->setValue(valueText); + + ValueThresholds thresholdsCopy = (thresholds ? *thresholds : ValueThresholds{}); + + listItem->setClickListener( + [this, configVal, range, categoryName, thresholdsCopy, labels](u64 keys) + { + if ((keys & HidNpadButton_A) == 0) + return false; + + std::uint32_t currentValue = this->configList->values[configVal]; + + if (thresholdsCopy.warning != 0 || thresholdsCopy.danger != 0) { + + tsl::changeTo( + currentValue, + range, + categoryName, + [this, configVal](std::uint32_t value) { + this->configList->values[configVal] = value; + Result rc = sysclkIpcSetConfigValues(this->configList); + if (R_FAILED(rc)) { + FatalGui::openWithResultCode("sysclkIpcSetConfigValues", rc); + return false; + } + this->lastContextUpdate = armGetSystemTick(); + return true; + }, + thresholdsCopy, + true, + labels // <── NEW + ); + } else { + + tsl::changeTo( + currentValue, + range, + categoryName, + [this, configVal](std::uint32_t value) { + this->configList->values[configVal] = value; + Result rc = sysclkIpcSetConfigValues(this->configList); + if (R_FAILED(rc)) { + FatalGui::openWithResultCode("sysclkIpcSetConfigValues", rc); + return false; + } + this->lastContextUpdate = armGetSystemTick(); + return true; + }, + ValueThresholds(), + false, + labels // <── NEW + ); + } + + return true; + }); + + this->listElement->addItem(listItem); + this->configButtons[configVal] = listItem; + this->configRanges[configVal] = range; +} + +void MiscGui::addFreqButton(SysClkConfigValue configVal, + const char* altName, + SysClkModule module, + const std::map& labels) +{ + const char* configName = altName ? altName : sysclkFormatConfigValue(configVal, true); + + tsl::elm::ListItem* listItem = new tsl::elm::ListItem(configName); + + uint64_t currentMHz = this->configList->values[configVal]; + char valueText[32]; + snprintf(valueText, sizeof(valueText), "%lu MHz", currentMHz); + listItem->setValue(valueText); + + listItem->setClickListener( + [this, configVal, module, labels](u64 keys) + { + if ((keys & HidNpadButton_A) == 0) + return false; + + std::uint32_t hzList[SYSCLK_FREQ_LIST_MAX]; + std::uint32_t hzCount; + + Result rc = sysclkIpcGetFreqList(module, hzList, SYSCLK_FREQ_LIST_MAX, &hzCount); + if (R_FAILED(rc)) { + FatalGui::openWithResultCode("sysclkIpcGetFreqList", rc); + return false; + } + + std::uint32_t currentHz = this->configList->values[configVal] * 1'000'000; + + tsl::changeTo( + currentHz, + hzList, + hzCount, + module, + [this, configVal](std::uint32_t hz) + { + uint64_t mhz = hz / 1'000'000; + this->configList->values[configVal] = mhz; + + Result rc = sysclkIpcSetConfigValues(this->configList); + if (R_FAILED(rc)) { + FatalGui::openWithResultCode("sysclkIpcSetConfigValues", rc); + return false; + } + + this->lastContextUpdate = armGetSystemTick(); + return true; + }, + false, + labels + ); + + return true; + }); + + this->listElement->addItem(listItem); + this->configButtons[configVal] = listItem; + + this->configRanges[configVal] = ValueRange(0, 0, 0, "MHz", 1); +} + void MiscGui::updateConfigToggles() { for (const auto& [value, toggle] : this->configToggles) { if (toggle != nullptr) @@ -40,21 +212,216 @@ void MiscGui::updateConfigToggles() { void MiscGui::listUI() { - this->listElement->addItem(new tsl::elm::CategoryHeader("Config")); - addConfigToggle(HocClkConfigValue_UncappedClocks); - addConfigToggle(HocClkConfigValue_OverwriteBoostMode); - addConfigToggle(HocClkConfigValue_SyncReverseNXMode); + this->listElement->addItem(new tsl::elm::CategoryHeader("Settings")); + addConfigToggle(HocClkConfigValue_UncappedClocks, nullptr); + addConfigToggle(HocClkConfigValue_OverwriteBoostMode, nullptr); + + // this->listElement->addItem(new tsl::elm::CategoryHeader("Experimental")); + addConfigToggle(HocClkConfigValue_ThermalThrottle, nullptr); + addConfigToggle(HocClkConfigValue_HandheldTDP, nullptr); + addConfigToggle(HocClkConfigValue_EnforceBoardLimit, nullptr); + std::map labels_pwr_r = { + {8600, "Official Rating"} + }; + std::map labels_pwr_l = { + {6400, "Official Rating"} + }; + ValueThresholds tdpThresholds(8600, 9500); + addConfigButton( + HocClkConfigValue_HandheldTDPLimit, + "TDP Threshold", + ValueRange(5000, 10000, 200, "mW", 1), + "Power", + &tdpThresholds, + labels_pwr_r + ); + + ValueThresholds tdpThresholdsLite(6400, 7500); + addConfigButton( + HocClkConfigValue_LiteTDPLimit, + "Lite TDP Threshold", + ValueRange(4000, 8000, 200, "mW", 1), + "Power", + &tdpThresholdsLite, + labels_pwr_l + ); + + ValueThresholds throttleThresholds(70, 80); + addConfigButton( + HocClkConfigValue_ThermalThrottleThreshold, + "Thermal Throttle Limit", + ValueRange(50, 85, 5, "°C", 1), + "Temp", + &throttleThresholds + ); + std::map cpu_freq_label_m = { + {612000000, "Sleep Mode"}, + {1020000000, "Stock"}, + {1224000000, "Dev OC"}, + {1785000000, "Boost Mode"}, + {1963000000, "Safe Max"}, + {2397000000, "Unsafe Max"}, + {2805000000, "Aboslute Max"}, + }; + + std::map cpu_freq_label_e = { + {612000000, "Sleep Mode"}, + {1020000000, "Stock"}, + {1224000000, "Dev OC"}, + {1785000000, "Boost Mode & Safe Max"}, + {2091000000, "Unsafe Max"}, + {2295000000, "Aboslute Max"}, + }; + + std::map gpu_freq_label_e = { + {76800000, "Boost Mode"}, + {307200000, "Handheld"}, + {384000000, "Handheld"}, + {460800000, "Handheld Safe Max"}, + {768000000, "Docked"}, + {844000000, "Safe Max"}, + {998400000, "Unsafe Max"}, + {1075200000, "Aboslute Max"}, + }; + + std::map gpu_freq_label_m = { + {76800000, "Boost Mode"}, + {307200000, "Handheld"}, + {384000000, "Handheld"}, + {460800000, "Handheld"}, + {614400000, "Handheld Safe Max"}, + {768000000, "Docked"}, + {1152200000, "Safe Max"}, + {1305600000, "Unsafe Max"}, + {1536000000, "Aboslute Max"}, + }; + + std::map emc_freq_label_e = { + {133120000, "Handheld"}, + {160000000, "Docked & Safe Max"}, + {213100000, "JEDEC Max"}, + {236000000, "Absolute Max"}, + }; + + + std::map emc_freq_label_m = { + {133120000, "Handheld"}, + {160000000, "Docked"}, + {186600000, "Safe Max (3733MT/s)"}, + {213300000, "Safe Max (4266MT/s)"}, + {320000000, "Absolute Max"}, + }; + + + this->listElement->addItem(new tsl::elm::CategoryHeader("Clocks")); + if(IsMariko()) { + addFreqButton(HocClkConfigValue_MarikoMaxCpuClock, nullptr, SysClkModule_CPU, cpu_freq_label_m); + addFreqButton(HocClkConfigValue_MarikoMaxGpuClock, nullptr, SysClkModule_GPU, gpu_freq_label_m); + addFreqButton(HocClkConfigValue_MarikoMaxMemClock, nullptr, SysClkModule_MEM, emc_freq_label_m); + } else { + addFreqButton(HocClkConfigValue_EristaMaxCpuClock, nullptr, SysClkModule_CPU, cpu_freq_label_e); + addFreqButton(HocClkConfigValue_EristaMaxGpuClock, nullptr, SysClkModule_GPU, gpu_freq_label_e); + addFreqButton(HocClkConfigValue_EristaMaxMemClock, nullptr, SysClkModule_MEM, emc_freq_label_e); + } + + this->listElement->addItem(new tsl::elm::CategoryHeader("EMC")); + + addConfigToggle(HocClkConfigValue_EMCDVFS, nullptr); + + std::map emc_voltage_label_m = { + {1100000, "Default"}, + {1175000, "Rating"}, + {1212500, "Safe Max"}, + }; + + std::map emc_voltage_label_e = { + {1125000, "Default"}, + {1175000, "Rating"}, + {1237500, "Safe Max"}, + }; + + + if(IsMariko()) { + ValueThresholds emcUvThresholds(1212500, 1250000); + addConfigButton( + HocClkConfigValue_EMCVdd2VoltageUV, + "EMC VDD2 Voltage", + ValueRange(1100000, 1237500, 12500, "mV", 1000, 1), + "EMC VDD2 Voltage", + &emcUvThresholds, + emc_voltage_label_m + ); + addConfigButton( + HocClkConfigValue_EMCVdd2VoltageUVStockMariko, + "EMC Stock VDD2 Voltage", + ValueRange(912500, 1175000, 12500, "mV", 1000, 1), + "EMC Stock VDD2 Voltage", + &emcUvThresholds, + emc_voltage_label_m + ); + } else { + ValueThresholds emcUvThresholds(1237500, 1300000); + addConfigButton( + HocClkConfigValue_EMCVdd2VoltageUV, + "EMC VDD2 Voltage", + ValueRange(1100000, 1237500, 12500, "mV", 1000, 1), + "EMC VDD2 Voltage", + &emcUvThresholds, + emc_voltage_label_e + ); + addConfigButton( + HocClkConfigValue_EMCVdd2VoltageUVStockErista, + "EMC Stock VDD2 Voltage", + ValueRange(1000000, 1175000, 12500, "mV", 1000, 1), + "EMC Stock VDD2 Voltage", + &emcUvThresholds, + emc_voltage_label_e + ); + } + + tsl::elm::ListItem* applyBtn = new tsl::elm::ListItem("Apply EMC Regs"); + applyBtn->setClickListener([](u64 keys) { + if (keys & HidNpadButton_A) { + Result rc = hocClkIpcUpdateEmcRegs(); + if (R_FAILED(rc)) { + FatalGui::openWithResultCode("hocClkIpcUpdateEmcRegs", rc); + return false; + } + return true; + } + return false; + }); + this->listElement->addItem(applyBtn); + + } void MiscGui::refresh() { BaseMenuGui::refresh(); - // Update the enabled toggle state - if (this->context && ++frameCounter >= 60) - { + if (this->context && ++frameCounter >= 60) { frameCounter = 0; - sysclkIpcGetConfigValues(this->configList); - updateConfigToggles(); - } -} + sysclkIpcGetConfigValues(this->configList); + + updateConfigToggles(); + + for (const auto& [configVal, button] : this->configButtons) { + uint64_t currentValue = this->configList->values[configVal]; + const ValueRange& range = this->configRanges[configVal]; + + char valueText[32]; + if (currentValue == 0) { + snprintf(valueText, sizeof(valueText), "%s", VALUE_DEFAULT_TEXT); + } else { + uint64_t displayValue = currentValue / range.divisor; + if (!range.suffix.empty()) { + snprintf(valueText, sizeof(valueText), "%lu %s", displayValue, range.suffix.c_str()); + } else { + snprintf(valueText, sizeof(valueText), "%lu", displayValue); + } + } + button->setValue(valueText); + } + } +} \ No newline at end of file diff --git a/Source/sys-clk/overlay/src/ui/gui/misc_gui.h b/Source/sys-clk/overlay/src/ui/gui/misc_gui.h index 0ad9f266..d60fc617 100644 --- a/Source/sys-clk/overlay/src/ui/gui/misc_gui.h +++ b/Source/sys-clk/overlay/src/ui/gui/misc_gui.h @@ -3,23 +3,38 @@ #include "base_menu_gui.h" #include #include +#include +#include "freq_choice_gui.h" +#include "value_choice_gui.h" class MiscGui : public BaseMenuGui { - public: - MiscGui(); - ~MiscGui(); - - void listUI() override; - void refresh() override; - protected: - SysClkConfigValueList* configList; - - std::map configToggles; - void addConfigToggle(SysClkConfigValue, const char*); - void updateConfigToggles(); - - tsl::elm::ToggleListItem* enabledToggle; - - u8 frameCounter = 60; +public: + MiscGui(); + ~MiscGui(); + void listUI() override; + void refresh() override; + +protected: + std::map configButtons; + std::map configRanges; // Store ranges for refresh + SysClkConfigValueList* configList; + std::map configToggles; + std::map>> configTrackbars; + + void addConfigToggle(SysClkConfigValue configVal, const char* altName); + void addConfigButton(SysClkConfigValue configVal, + const char* altName, + const ValueRange& range, + const std::string& categoryName, + const ValueThresholds* thresholds, + const std::map& labels = {}); + void addFreqButton(SysClkConfigValue configVal, + const char* altName, + SysClkModule module, + const std::map& labels = {}); + void updateConfigToggles(); + + tsl::elm::ToggleListItem* enabledToggle; + u8 frameCounter = 60; }; \ No newline at end of file diff --git a/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.cpp b/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.cpp new file mode 100644 index 00000000..07074d51 --- /dev/null +++ b/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.cpp @@ -0,0 +1,121 @@ +#include "value_choice_gui.h" +#include "../format.h" +#include "fatal_gui.h" +#include +#include + +ValueChoiceGui::ValueChoiceGui(std::uint32_t selectedValue, + const ValueRange& range, + const std::string& categoryName, + ValueChoiceListener listener, + const ValueThresholds& thresholds, + bool enableThresholds, + std::map labels) + : selectedValue(selectedValue), + range(range), + categoryName(categoryName), + listener(listener), + thresholds(thresholds), + enableThresholds(enableThresholds), + labels(labels) +{ +} + +ValueChoiceGui::~ValueChoiceGui() +{ +} + +std::string ValueChoiceGui::formatValue(std::uint32_t value) +{ + std::ostringstream oss; + + if (value == 0) { + return VALUE_DEFAULT_TEXT; + } + + double displayValue = static_cast(value) / static_cast(range.divisor); + + oss << std::fixed << std::setprecision(range.decimalPlaces) << displayValue; + + if (!range.suffix.empty()) { + oss << " " << range.suffix; + } + return oss.str(); +} + +int ValueChoiceGui::getSafetyLevel(std::uint32_t value) +{ + if (value > thresholds.danger) { + return 2; + } + if (value > thresholds.warning) { + return 1; + } + return 0; +} + +tsl::elm::ListItem* ValueChoiceGui::createValueListItem(std::uint32_t value, bool selected, int safety) +{ + std::string text = formatValue(value); + if (selected) { + text += " \uE14B"; + } + + std::string rightText = ""; + auto it = labels.find(value); + if (it != labels.end()) { + rightText = it->second; + } + + tsl::elm::ListItem* listItem = new tsl::elm::ListItem(text, rightText, false); + + switch (safety) + { + case 0: + listItem->setTextColor(tsl::Color(255, 255, 255, 255)); + listItem->setValueColor(tsl::Color(255, 255, 255, 255)); + break; + case 1: + listItem->setTextColor(tsl::Color(255, 165, 0, 255)); + listItem->setValueColor(tsl::Color(255, 165, 0, 255)); + break; + case 2: + listItem->setTextColor(tsl::Color(255, 0, 0, 255)); + listItem->setValueColor(tsl::Color(255, 0, 0, 255)); + break; + } + + if (!rightText.empty()) + listItem->setValueColor(tsl::Color(180, 180, 180, 255)); + + listItem->setClickListener([this, value](u64 keys) + { + if ((keys & HidNpadButton_A) == HidNpadButton_A && this->listener) { + if (this->listener(value)) { + tsl::goBack(); + } + return true; + } + return false; + }); + + return listItem; +} + +void ValueChoiceGui::listUI() +{ + if (!categoryName.empty()) { + this->listElement->addItem(new tsl::elm::CategoryHeader(categoryName)); + } + + this->listElement->addItem(this->createValueListItem(0, this->selectedValue == 0, 0)); + + for (std::uint32_t value = range.min; value <= range.max; value += range.step) + { + int safety = getSafetyLevel(value); + bool selected = (value == this->selectedValue); + this->listElement->addItem(this->createValueListItem(value, selected, safety)); + } + + this->listElement->jumpToItem("", "\uE14B"); +} diff --git a/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.h b/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.h new file mode 100644 index 00000000..278c8144 --- /dev/null +++ b/Source/sys-clk/overlay/src/ui/gui/value_choice_gui.h @@ -0,0 +1,93 @@ +/* + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- + * "THE BEER-WARE LICENSE" (Revision 42): + * , , + * wrote this file. As long as you retain this notice you can do whatever you + * want with this stuff. If you meet any of us some day, and you think this + * stuff is worth it, you can buy us a beer in return. - The sys-clk authors + * -------------------------------------------------------------------------- + */ + + +#pragma once + +#include +#include +#include +#include +#include "base_menu_gui.h" + +using ValueChoiceListener = std::function; + +#define VALUE_DEFAULT_TEXT "Default" + +struct ValueRange { + std::uint32_t min; + std::uint32_t max; + std::uint32_t step; + std::string suffix; + std::uint32_t divisor; + int decimalPlaces; + + ValueRange() + : min(0), max(0), step(1), suffix(""), divisor(1), decimalPlaces(0) {} + + ValueRange(std::uint32_t min, std::uint32_t max, std::uint32_t step, + const std::string& suffix = "", std::uint32_t divisor = 1, int decimalPlaces = 0) + : min(min), max(max), step(step), suffix(suffix), + divisor(divisor), decimalPlaces(decimalPlaces) {} +}; + +struct ValueThresholds { + std::uint32_t warning; + std::uint32_t danger; + + ValueThresholds(std::uint32_t warning = 0, std::uint32_t danger = 0) + : warning(warning), danger(danger) {} +}; + +class ValueChoiceGui : public BaseMenuGui +{ +protected: + std::uint32_t selectedValue; + ValueRange range; + std::string categoryName; + ValueChoiceListener listener; + ValueThresholds thresholds; + bool enableThresholds; + + // NEW — map of value → right-side text (like version numbers) + std::map labels; + + tsl::elm::ListItem* createValueListItem(std::uint32_t value, bool selected, int safety); + std::string formatValue(std::uint32_t value); + int getSafetyLevel(std::uint32_t value); + +public: + ValueChoiceGui(std::uint32_t selectedValue, + const ValueRange& range, + const std::string& categoryName, + ValueChoiceListener listener, + const ValueThresholds& thresholds = ValueThresholds(), + bool enableThresholds = false, + std::map labels = {}); + ~ValueChoiceGui(); + + void listUI() override; +}; diff --git a/Source/sys-clk/overlay/src/ui/style.h b/Source/sys-clk/overlay/src/ui/style.h index 86b56d89..fa751ddc 100644 --- a/Source/sys-clk/overlay/src/ui/style.h +++ b/Source/sys-clk/overlay/src/ui/style.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include diff --git a/Source/sys-clk/sysmodule/Makefile b/Source/sys-clk/sysmodule/Makefile index cc97fab7..ae8bfa66 100644 --- a/Source/sys-clk/sysmodule/Makefile +++ b/Source/sys-clk/sysmodule/Makefile @@ -17,7 +17,7 @@ include $(DEVKITPRO)/libnx/switch_rules # INCLUDES is a list of directories containing header files # EXEFS_SRC is the optional input directory containing data copied into exefs, if anything this normally should only contain "main.npdm". #--------------------------------------------------------------------------------- -TARGET := sys-clk +TARGET := horizon-oc BUILD := build OUTDIR := out RESOURCES := res @@ -39,7 +39,7 @@ DEFINES := -DDISABLE_IPC -DTARGET="\"$(TARGET)\"" -DTARGET_VERSION="\"$(TARGET_V ARCH := -march=armv8-a+crc+crypto -mtune=cortex-a57 -mtp=soft -fPIE -CFLAGS := -g -Wall -O2 -ffunction-sections \ +CFLAGS := -g -Wall -Os -ffunction-sections \ $(ARCH) $(DEFINES) CFLAGS += $(INCLUDE) -D__SWITCH__ diff --git a/Source/sys-clk/sysmodule/lib/minIni/include/minIni.h b/Source/sys-clk/sysmodule/lib/minIni/include/minIni.h index b4f10673..42c5bdb6 100644 --- a/Source/sys-clk/sysmodule/lib/minIni/include/minIni.h +++ b/Source/sys-clk/sysmodule/lib/minIni/include/minIni.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -7,6 +23,7 @@ * stuff is worth it, you can buy us a beer in return. - The sys-clk authors * -------------------------------------------------------------------------- */ + #pragma once #ifdef __cplusplus diff --git a/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt.h b/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt.h index 6361703d..96e0e42d 100644 --- a/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt.h +++ b/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include "nxExt/apm_ext.h" diff --git a/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/apm_ext.h b/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/apm_ext.h index e1ad78cf..aa03fce6 100644 --- a/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/apm_ext.h +++ b/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/apm_ext.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #ifdef __cplusplus diff --git a/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/cpp/lockable_mutex.h b/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/cpp/lockable_mutex.h index 44f19f2d..6d74875c 100644 --- a/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/cpp/lockable_mutex.h +++ b/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/cpp/lockable_mutex.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #ifdef __cplusplus diff --git a/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/i2c.h b/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/i2c.h index 48656424..61047b2c 100644 --- a/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/i2c.h +++ b/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/i2c.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #ifdef __cplusplus diff --git a/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/ipc_server.h b/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/ipc_server.h index 4dd8f88f..fe002f5b 100644 --- a/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/ipc_server.h +++ b/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/ipc_server.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #ifdef __cplusplus diff --git a/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/max17050.h b/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/max17050.h index 05924dd7..2810fd8c 100644 --- a/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/max17050.h +++ b/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/max17050.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #ifdef __cplusplus diff --git a/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/t210.h b/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/t210.h index 334691e9..09d625c2 100644 --- a/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/t210.h +++ b/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/t210.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #ifdef __cplusplus diff --git a/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/tmp451.h b/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/tmp451.h index 587596b6..a332eaa8 100644 --- a/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/tmp451.h +++ b/Source/sys-clk/sysmodule/lib/nxExt/include/nxExt/tmp451.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #ifdef __cplusplus diff --git a/Source/sys-clk/sysmodule/lib/nxExt/src/apm_ext.c b/Source/sys-clk/sysmodule/lib/nxExt/src/apm_ext.c index 7815e0a1..96997ff3 100644 --- a/Source/sys-clk/sysmodule/lib/nxExt/src/apm_ext.c +++ b/Source/sys-clk/sysmodule/lib/nxExt/src/apm_ext.c @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #include "nxExt/apm_ext.h" #include diff --git a/Source/sys-clk/sysmodule/lib/nxExt/src/i2c.c b/Source/sys-clk/sysmodule/lib/nxExt/src/i2c.c index 9a82cc1d..4c43f54d 100644 --- a/Source/sys-clk/sysmodule/lib/nxExt/src/i2c.c +++ b/Source/sys-clk/sysmodule/lib/nxExt/src/i2c.c @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #include "nxExt/i2c.h" #define I2C_CMD_SND 0 diff --git a/Source/sys-clk/sysmodule/lib/nxExt/src/ipc_server.c b/Source/sys-clk/sysmodule/lib/nxExt/src/ipc_server.c index 1953c707..99db3f6c 100644 --- a/Source/sys-clk/sysmodule/lib/nxExt/src/ipc_server.c +++ b/Source/sys-clk/sysmodule/lib/nxExt/src/ipc_server.c @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #include "nxExt/ipc_server.h" #include diff --git a/Source/sys-clk/sysmodule/perms.json b/Source/sys-clk/sysmodule/perms.json index e3417e2b..67ca8fe3 100644 --- a/Source/sys-clk/sysmodule/perms.json +++ b/Source/sys-clk/sysmodule/perms.json @@ -1,10 +1,10 @@ { - "name": "sys:clk", + "name": "horizon:oc", "title_id": "0x00FF0000636C6BFF", "title_id_range_min": "0x00FF0000636C6BFF", "title_id_range_max": "0x00FF0000636C6BFF", - "main_thread_stack_size": "0x00004000", - "main_thread_priority": 49, + "main_thread_stack_size": "0x00008000", + "main_thread_priority": 63, "default_cpu_id": 3, "process_category": 0, "is_retail": true, @@ -18,15 +18,15 @@ "*" ], "service_host": [ - "sys:clk" + "horizon:oc" ], "kernel_capabilities": [ { "type": "kernel_flags", "value": { "highest_thread_priority": 63, - "lowest_thread_priority": 24, - "lowest_cpu_id": 3, + "lowest_thread_priority": 63, + "lowest_cpu_id": 0, "highest_cpu_id": 3 } }, diff --git a/Source/sys-clk/sysmodule/src/board.cpp b/Source/sys-clk/sysmodule/src/board.cpp index 5be2a4f0..700af72f 100644 --- a/Source/sys-clk/sysmodule/src/board.cpp +++ b/Source/sys-clk/sysmodule/src/board.cpp @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,12 +24,17 @@ * -------------------------------------------------------------------------- */ + #include #include "board.h" #include "errors.h" #define HOSSVC_HAS_CLKRST (hosversionAtLeast(8,0,0)) #define HOSSVC_HAS_TC (hosversionAtLeast(5,0,0)) +#define NVGPU_GPU_IOCTL_PMU_GET_GPU_LOAD 0x80044715 + +Result nvCheck = 1; +u32 fd = 0; static SysClkSocType g_socType = SysClkSocType_Erista; @@ -100,6 +121,11 @@ void Board::Initialize() rc = tmp451Initialize(); ASSERT_RESULT_OK(rc, "tmp451Initialize"); + // u32 fd = 0; + + // if (R_SUCCEEDED(nvInitialize())) nvCheck = nvOpen(&fd, "/dev/nvhost-ctrl-gpu"); + + FetchHardwareInfos(); } @@ -124,6 +150,7 @@ void Board::Exit() max17050Exit(); tmp451Exit(); + nvExit(); } SysClkProfile Board::GetProfile() @@ -446,16 +473,23 @@ std::int32_t Board::GetPowerMw(SysClkPowerSensor sensor) return 0; } -std::uint32_t Board::GetRamLoad(SysClkRamLoad loadSource) +std::uint32_t Board::GetPartLoad(SysClkPartLoad loadSource) { + // u32 temp, GPU_Load_u = 0; + switch(loadSource) { - case SysClkRamLoad_All: + case SysClkPartLoad_EMC: return t210EmcLoadAll(); - case SysClkRamLoad_Cpu: + case SysClkPartLoad_EMCCpu: return t210EmcLoadCpu(); + // case HocClkPartLoad_GPU: + // #define gpu_samples_average 10 + // // nvIoctl(fd, NVGPU_GPU_IOCTL_PMU_GET_GPU_LOAD, &temp); + // GPU_Load_u = ((GPU_Load_u * (gpu_samples_average-1)) + temp) / gpu_samples_average; + // return GPU_Load_u / 10; default: - ASSERT_ENUM_VALID(SysClkRamLoad, loadSource); + ASSERT_ENUM_VALID(SysClkPartLoad, loadSource); } return 0; @@ -465,6 +499,7 @@ SysClkSocType Board::GetSocType() { return g_socType; } + void Board::FetchHardwareInfos() { u64 sku = 0; @@ -484,4 +519,4 @@ void Board::FetchHardwareInfos() default: g_socType = SysClkSocType_Erista; } -} \ No newline at end of file +} diff --git a/Source/sys-clk/sysmodule/src/board.h b/Source/sys-clk/sysmodule/src/board.h index a3828dea..ae654d2f 100644 --- a/Source/sys-clk/sysmodule/src/board.h +++ b/Source/sys-clk/sysmodule/src/board.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include #include @@ -34,7 +51,7 @@ class Board static void GetFreqList(SysClkModule module, std::uint32_t* outList, std::uint32_t maxCount, std::uint32_t* outCount); static std::uint32_t GetTemperatureMilli(SysClkThermalSensor sensor); static std::int32_t GetPowerMw(SysClkPowerSensor sensor); - static std::uint32_t GetRamLoad(SysClkRamLoad load); + static std::uint32_t GetPartLoad(SysClkPartLoad load); static SysClkSocType GetSocType(); protected: diff --git a/Source/sys-clk/sysmodule/src/clock_manager.cpp b/Source/sys-clk/sysmodule/src/clock_manager.cpp index 2ecd7ec0..bb338d7d 100644 --- a/Source/sys-clk/sysmodule/src/clock_manager.cpp +++ b/Source/sys-clk/sysmodule/src/clock_manager.cpp @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,8 @@ * -------------------------------------------------------------------------- */ +#include "notification.h" + #include "clock_manager.h" #include #include "file_utils.h" @@ -16,6 +34,12 @@ #include "errors.h" #include "ipc_service.h" +#define HOSPPC_HAS_BOOST (hosversionAtLeast(7,0,0)) + +bool HAS_TDP_BEEN_FIRED = false; +bool HAS_EBL_BEEN_FIRED = false; +bool HAS_TT_BEEN_FIRED = false; + ClockManager *ClockManager::instance = NULL; ClockManager *ClockManager::GetInstance() @@ -42,7 +66,6 @@ void ClockManager::Initialize() ClockManager::ClockManager() { this->config = Config::CreateDefault(); - this->context = new SysClkContext; this->context->applicationId = 0; this->context->profile = SysClkProfile_Handheld; @@ -122,7 +145,16 @@ std::uint32_t ClockManager::GetMaxAllowedHz(SysClkModule module, SysClkProfile p { if (profile < SysClkProfile_HandheldCharging) { - return Board::GetSocType() == SysClkSocType_Mariko ? 614400000 : 460800000; + switch(Board::GetSocType()) { + case SysClkSocType_Erista: + return 460800000; + case SysClkSocType_Mariko: + return 614400000; + case SysClkSocType_MarikoLite: + return 537600000; + default: + return 4294967294; + } } else if (profile <= SysClkProfile_HandheldChargingUSB) { @@ -201,17 +233,102 @@ void ClockManager::RefreshFreqTableRow(SysClkModule module) void ClockManager::Tick() { + + std::uint32_t mode = 0; + AppletOperationMode opMode = appletGetOperationMode(); + Result rc = apmExtGetCurrentPerformanceConfiguration(&mode); + ASSERT_RESULT_OK(rc, "apmExtGetCurrentPerformanceConfiguration"); + + + if(this->config->GetConfigValue(HocClkConfigValue_EMCDVFS)) { + + #define DEFAULT_FREQ_MHZ 1600 + #define DEFAULT_FREQ_MHZ_M 1862 + + int ram_mhz = Board::GetHz((SysClkModule)SysClkModule_MEM) / 1000000; + + if (Board::GetSocType() == SysClkSocType_Mariko) { + if(ram_mhz > DEFAULT_FREQ_MHZ_M) + set_sd1_voltage(this->config->GetConfigValue(HocClkConfigValue_EMCVdd2VoltageUV)); + else + set_sd1_voltage(this->config->GetConfigValue(HocClkConfigValue_EMCVdd2VoltageUVStockMariko)); + } else { + if(ram_mhz > DEFAULT_FREQ_MHZ) + set_sd1_voltage(this->config->GetConfigValue(HocClkConfigValue_EMCVdd2VoltageUV)); + else + set_sd1_voltage(this->config->GetConfigValue(HocClkConfigValue_EMCVdd2VoltageUVStockErista)); + } + } + + if(this->config->GetConfigValue(HocClkConfigValue_HandheldTDP) && opMode == AppletOperationMode_Handheld) { + if(Board::GetSocType() == SysClkSocType_MarikoLite) { + if(Board::GetPowerMw(SysClkPowerSensor_Avg) < -(int)this->config->GetConfigValue(HocClkConfigValue_LiteTDPLimit)) { + if(!HAS_TDP_BEEN_FIRED) + writeNotification("Horizon OC\nTDP has been activated"); + HAS_TDP_BEEN_FIRED = true; + ResetToStockClocks(); + return; + } else { + HAS_TDP_BEEN_FIRED = false; + } + } else { + if(Board::GetPowerMw(SysClkPowerSensor_Avg) < -(int)this->config->GetConfigValue(HocClkConfigValue_HandheldTDPLimit)) { + if(!HAS_TDP_BEEN_FIRED) + writeNotification("Horizon OC\nTDP has been activated"); + HAS_TDP_BEEN_FIRED = true; + ResetToStockClocks(); + return; + } else { + HAS_TDP_BEEN_FIRED = false; + } + } + } else if(opMode == AppletOperationMode_Console && this->config->GetConfigValue(HocClkConfigValue_EnforceBoardLimit)) { + if(Board::GetPowerMw(SysClkPowerSensor_Avg) < 0) { + if(!HAS_EBL_BEEN_FIRED) + writeNotification("Horizon OC\nBoard Limit has been exeeded"); + HAS_EBL_BEEN_FIRED = true; + ResetToStockClocks(); + return; + } else { + HAS_EBL_BEEN_FIRED = false; + } + } + + if(this->config->GetConfigValue(HocClkConfigValue_ThermalThrottle)) { + if(tmp451TempSoc() / 1000 > (int)this->config->GetConfigValue(HocClkConfigValue_ThermalThrottleThreshold)) { + if(!HAS_TT_BEEN_FIRED) + writeNotification("Horizon OC\nThermal Throttle has started"); + HAS_TT_BEEN_FIRED = true; + ResetToStockClocks(); + return; + } else { + HAS_TT_BEEN_FIRED = false; + } + } + std::scoped_lock lock{this->contextMutex}; if (this->RefreshContext() || this->config->Refresh()) { std::uint32_t targetHz = 0; std::uint32_t maxHz = 0; std::uint32_t nearestHz = 0; + + if(apmExtIsBoostMode(mode) && !this->config->GetConfigValue(HocClkConfigValue_OverwriteBoostMode)) { + ResetToStockClocks(); + return; + } + + + if(this->config->GetConfigValue(HocClkConfigValue_HandheldGovernor) && opMode == AppletOperationMode_Handheld) { + + } + if(this->config->GetConfigValue(HocClkConfigValue_DockedGovernor) && opMode == AppletOperationMode_Console) { + + } for (unsigned int module = 0; module < SysClkModule_EnumMax; module++) { - targetHz = this->context->overrideFreqs[module]; -// if (!this->config->GetConfigValue(HocClkConfigValue_DockedGovernor) || !this->config->GetConfigValue(HocClkConfigValue_HandheldGovernor)) -// { + targetHz = this->context->overrideFreqs[module]; + if (!targetHz) { targetHz = this->config->GetAutoClockHz(this->context->applicationId, (SysClkModule)module, this->context->profile); @@ -221,9 +338,7 @@ void ClockManager::Tick() { maxHz = this->GetMaxAllowedHz((SysClkModule)module, this->context->profile); nearestHz = this->GetNearestHz((SysClkModule)module, targetHz, maxHz); - - if (nearestHz != this->context->freqs[module] && this->context->enabled/* && !apmExtIsBoostMode(this->context->perfConfId) && !this->config->GetConfigValue(HocClkConfigValue_OverwriteBoostMode)*/) - { + if (nearestHz != this->context->freqs[module] && this->context->enabled) { FileUtils::LogLine( "[mgr] %s clock set : %u.%u MHz (target = %u.%u MHz)", Board::GetModuleName((SysClkModule)module, true), @@ -232,29 +347,18 @@ void ClockManager::Tick() Board::SetHz((SysClkModule)module, nearestHz); this->context->freqs[module] = nearestHz; - } - // else - // { - // Board::ResetToStockCpu(); - // Board::ResetToStockGpu(); - // } - // } - // } else { - // #define GOVERNOR_LOAD_THRESHOLD 80 - // if(apmExtIsBoostMode(this->context->perfConfId)) { - // Board::ResetToStockCpu(); // GOVERNOR: Reset to stock clocks if boost mode (dont use governor when boosted) - // Board::ResetToStockGpu(); - // } else { - // // Actually run the CPU governor - // if(t210EmcLoadCpu() > GOVERNOR_LOAD_THRESHOLD) { - // realHz = targetHz / 1000000 - // } - // } - } + } + } + } } } +void ClockManager::ResetToStockClocks() { + Board::ResetToStockCpu(); + Board::ResetToStockGpu(); +} + void ClockManager::WaitForNextTick() { svcSleepThread(this->GetConfig()->GetConfigValue(SysClkConfigValue_PollingIntervalMs) * 1000000ULL); @@ -292,7 +396,7 @@ bool ClockManager::RefreshContext() // restore clocks to stock values on app or profile change if (hasChanged) { - this->rnxSync->ToggleSync(this->GetConfig()->GetConfigValue(HocClkConfigValue_SyncReverseNXMode)); + // this->rnxSync->ToggleSync(this->GetConfig()->GetConfigValue(HocClkConfigValue_SyncReverseNXMode)); Board::ResetToStock(); this->WaitForNextTick(); } @@ -378,9 +482,9 @@ bool ClockManager::RefreshContext() } // ram load do not and should not force a refresh, hasChanged untouched - for (unsigned int loadSource = 0; loadSource < SysClkRamLoad_EnumMax; loadSource++) + for (unsigned int loadSource = 0; loadSource < SysClkPartLoad_EnumMax; loadSource++) { - this->context->ramLoad[loadSource] = Board::GetRamLoad((SysClkRamLoad)loadSource); + this->context->partLoad[loadSource] = Board::GetPartLoad((SysClkPartLoad)loadSource); } if (this->ConfigIntervalTimeout(SysClkConfigValue_CsvWriteIntervalMs, ns, &this->lastCsvWriteNs)) @@ -394,4 +498,50 @@ bool ClockManager::RefreshContext() void ClockManager::SetRNXRTMode(ReverseNXMode mode) { this->rnxSync->SetRTMode(mode); +} + +void ClockManager::set_sd1_voltage(uint32_t voltage_uv) +{ + // SD1 parameters + const u32 uv_step = 12500; + const u32 uv_min = 600000; + const u32 uv_max = 1237500; + const u8 volt_addr = 0x17; // MAX77620_REG_SD1 + const u8 volt_mask = 0x7F; // MAX77620_SD1_VOLT_MASK + + if (voltage_uv < uv_min || voltage_uv > uv_max) + return; + + u32 mult = (voltage_uv + uv_step - 1 - uv_min) / uv_step; + mult = mult & volt_mask; + + I2cSession session; + Result res = i2cOpenSession(&session, I2cDevice_Max77620Pmic); + if (R_FAILED(res)) { + return; + } + + u8 current_val = 0; + res = i2csessionSendAuto(&session, &volt_addr, 1, I2cTransactionOption_Start); + if (R_FAILED(res)) { + writeNotification("I2C write failed. This may be a hardware issue"); + i2csessionClose(&session); + return; + } + + res = i2csessionReceiveAuto(&session, ¤t_val, 1, I2cTransactionOption_Stop); + if (R_FAILED(res)) { + writeNotification("I2C write failed. This may be a hardware issue"); + i2csessionClose(&session); + return; + } + + // Mask in the new voltage bits, preserving other bits + u8 new_val = (current_val & ~volt_mask) | mult; + + // Write back register with START and STOP conditions + u8 write_buf[2] = {volt_addr, new_val}; + res = i2csessionSendAuto(&session, write_buf, sizeof(write_buf), I2cTransactionOption_All); + + i2csessionClose(&session); } \ No newline at end of file diff --git a/Source/sys-clk/sysmodule/src/clock_manager.h b/Source/sys-clk/sysmodule/src/clock_manager.h index 125c3a1e..9fd92c00 100644 --- a/Source/sys-clk/sysmodule/src/clock_manager.h +++ b/Source/sys-clk/sysmodule/src/clock_manager.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,10 +24,12 @@ * -------------------------------------------------------------------------- */ + #pragma once #include #include +#include #include "config.h" #include "board.h" @@ -37,6 +55,7 @@ class ClockManager bool Running(); void GetFreqList(SysClkModule module, std::uint32_t* list, std::uint32_t maxCount, std::uint32_t* outCount); void Tick(); + void ResetToStockClocks(); void WaitForNextTick(); void SetRNXRTMode(ReverseNXMode mode); struct { @@ -51,6 +70,7 @@ class ClockManager bool ConfigIntervalTimeout(SysClkConfigValue intervalMsConfigValue, std::uint64_t ns, std::uint64_t* lastLogNs); void RefreshFreqTableRow(SysClkModule module); bool RefreshContext(); + void set_sd1_voltage(uint32_t voltage_uv); static ClockManager *instance; diff --git a/Source/sys-clk/sysmodule/src/config.cpp b/Source/sys-clk/sysmodule/src/config.cpp index e8c40f5e..7faa4f2d 100644 --- a/Source/sys-clk/sysmodule/src/config.cpp +++ b/Source/sys-clk/sysmodule/src/config.cpp @@ -1,3 +1,20 @@ +/* + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + /* * -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): @@ -470,4 +487,4 @@ bool Config::SetConfigValues(SysClkConfigValueList* configValues, bool immediate } return true; -} +} \ No newline at end of file diff --git a/Source/sys-clk/sysmodule/src/config.h b/Source/sys-clk/sysmodule/src/config.h index 8893fd62..d7f2ad62 100644 --- a/Source/sys-clk/sysmodule/src/config.h +++ b/Source/sys-clk/sysmodule/src/config.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include #include diff --git a/Source/sys-clk/sysmodule/src/emc_patcher.cpp b/Source/sys-clk/sysmodule/src/emc_patcher.cpp new file mode 100644 index 00000000..9e34bdac --- /dev/null +++ b/Source/sys-clk/sysmodule/src/emc_patcher.cpp @@ -0,0 +1,91 @@ +#include "emc_patcher.h" +#include "file_utils.h" +#include "board.h" + + +#define MC_BASE 0x70019000 +#define EMC_BASE 0x7001B000 +#define MC_EMC_BASE_SIZE 0x1000 +#define EMC_TIMING_CONTROL_0 0x28 +#define EMC_RAS_0 0x34 +#define EMC_RAS_BIT_END 5 + +#define HOSSVC_HAS_MM (hosversionAtLeast(10,0,0)) + + +EMCpatcher* EMCpatcher::instance = nullptr; + +EMCpatcher* EMCpatcher::GetInstance() +{ + return instance; +} + +void EMCpatcher::Initialize() +{ + if (!instance) + { + instance = new EMCpatcher(); + FileUtils::LogLine("[emc] Initialized EMCpatcher"); + } +} + +Config *EMCpatcher::GetConfig() +{ + return this->config; +} + +void EMCpatcher::Exit() +{ + if (instance) + { + FileUtils::LogLine("[emc] Exiting EMCpatcher"); + delete instance; + instance = nullptr; + } +} + +EMCpatcher::EMCpatcher() +{ + this->config = Config::CreateDefault(); +} + + + +EMCpatcher::~EMCpatcher() +{ + delete this->config; +} + +void EMCpatcher::Run() +{ + std::scoped_lock lock{this->patcherMutex}; + this->config->Refresh(); + this->ApplyEMCPatch(); +} + + +void EMCpatcher::ApplyEMCPatch() +{ + // if(HOSSVC_HAS_MM) { // only for 10.0.0+, older versions need rewrites + // u64 mc_virt_addr = 0; + // u64 mc_out_size = 0; + // u64 emc_virt_addr = 0; + // u64 emc_out_size = 0; + // Result rc; + + // // rc = svcQueryMemoryMapping(&mc_virt_addr, &mc_out_size, MC_BASE, MC_EMC_BASE_SIZE); // map mc + // // ASSERT_RESULT_OK(rc, "svcQueryMemoryMapping"); + + // // rc = svcQueryMemoryMapping(&emc_virt_addr, &emc_out_size, EMC_BASE, MC_EMC_BASE_SIZE); // map emc + // // ASSERT_RESULT_OK(rc, "svcQueryMemoryMapping"); + + // write_reg64(EMC_BASE, EMC_RAS_0, 1); + + // write_reg64(EMC_BASE, EMC_TIMING_CONTROL_0, 0x1); // apply shadow regs + + + // // svcUnmapMemory((void *)mc_virt_addr, (void *)MC_BASE, MC_EMC_BASE_SIZE); // clean up + // // svcUnmapMemory((void *)emc_virt_addr, (void *)EMC_BASE, MC_EMC_BASE_SIZE); + + // } +} diff --git a/Source/sys-clk/sysmodule/src/emc_patcher.h b/Source/sys-clk/sysmodule/src/emc_patcher.h new file mode 100644 index 00000000..f2f13935 --- /dev/null +++ b/Source/sys-clk/sysmodule/src/emc_patcher.h @@ -0,0 +1,73 @@ +#pragma once + +#include +#include +#include "config.h" +#include +#include "errors.h" + +// Read a 32-bit register via libnx SVC +static inline uint32_t read_reg64(uint64_t phys_addr, uint32_t offset) { + uint32_t value = 0; + Result rc = svcReadWriteRegister(&value, phys_addr + offset, 0, false); + if (R_FAILED(rc)) { + // Handle failure if needed + return 0; + } + return value; +} + +// Write a 32-bit register via libnx SVC +static inline void write_reg64(uint64_t phys_addr, uint32_t offset, uint32_t value) { + Result rc = svcReadWriteRegister(NULL, phys_addr + offset, value, true); + if (R_FAILED(rc)) { + // Handle failure if needed + } +} + +// Bitfield helper remains the same +static inline uint32_t set_bits(uint32_t reg_value, uint8_t start_bit, uint8_t end_bit, uint32_t value) +{ + if (end_bit < start_bit || end_bit > 31) + return reg_value; + + uint32_t mask = ((1u << (end_bit - start_bit + 1)) - 1u) << start_bit; + reg_value = (reg_value & ~mask) | ((value << start_bit) & mask); + return reg_value; +} + +/* Primary timings. */ +const std::array tRCD_values = {18, 17, 16, 15, 14, 13, 12, 11}; +const std::array tRP_values = {18, 17, 16, 15, 14, 13, 12, 11}; +const std::array tRAS_values = {42, 36, 34, 32, 30, 28, 26, 24, 22, 20}; + +/* Secondary timings. */ +const std::array tRRD_values = {10.0, 7.5, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0}; +const std::array tRFC_values = {140, 120, 100, 80, 60, 40}; +const std::array tRTW_values = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; /* Is this even correct? */ +const std::array tWTR_values = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; +const std::array tREFpb_values = {488, 732, 488 * 2, 488 * 3, 488 * 4, 488 * 6, 488 * 8}; /* TODO: Figure out if it's actually 8 and if this is even right. */ + +struct SOC_THERM_THERMCTL_LEVEL0_GROUP_CPU_0 { + +}; + +class EMCpatcher +{ +private: + static EMCpatcher* instance; + Config* config; + std::mutex patcherMutex; + +public: + static EMCpatcher* GetInstance(); + static void Initialize(); + Config *GetConfig(); + static void Exit(); + + EMCpatcher(); + ~EMCpatcher(); + + void Run(); + void ApplyEMCPatch(); +}; diff --git a/Source/sys-clk/sysmodule/src/errors.cpp b/Source/sys-clk/sysmodule/src/errors.cpp index c4913050..f94b381d 100644 --- a/Source/sys-clk/sysmodule/src/errors.cpp +++ b/Source/sys-clk/sysmodule/src/errors.cpp @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #include "errors.h" #include #include diff --git a/Source/sys-clk/sysmodule/src/errors.h b/Source/sys-clk/sysmodule/src/errors.h index d626d920..66aa041e 100644 --- a/Source/sys-clk/sysmodule/src/errors.h +++ b/Source/sys-clk/sysmodule/src/errors.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include diff --git a/Source/sys-clk/sysmodule/src/fancontrol.c b/Source/sys-clk/sysmodule/src/fancontrol.c index 145a490e..11e1be1d 100644 --- a/Source/sys-clk/sysmodule/src/fancontrol.c +++ b/Source/sys-clk/sysmodule/src/fancontrol.c @@ -2,17 +2,17 @@ #include "tmp451.h" //Fan curve table -const TemperaturePoint defaultTable[] = +TemperaturePoint defaultTable[] = { - { .temperature_c = 25.0, .fanLevel_f = 0.10 }, - { .temperature_c = 30.0, .fanLevel_f = 0.20 }, - { .temperature_c = 35.0, .fanLevel_f = 0.30 }, - { .temperature_c = 40.0, .fanLevel_f = 0.40 }, - { .temperature_c = 45.0, .fanLevel_f = 0.50 }, - { .temperature_c = 50.0, .fanLevel_f = 0.60 }, - { .temperature_c = 55.0, .fanLevel_f = 0.70 }, - { .temperature_c = 60.0, .fanLevel_f = 0.80 }, - { .temperature_c = 65.0, .fanLevel_f = 0.90 }, + { .temperature_c = 25.0, .fanLevel_f = 0.00 }, + { .temperature_c = 30.0, .fanLevel_f = 0.00 }, + { .temperature_c = 35.0, .fanLevel_f = 0.00 }, + { .temperature_c = 40.0, .fanLevel_f = 0.00 }, + { .temperature_c = 45.0, .fanLevel_f = 0.30 }, + { .temperature_c = 50.0, .fanLevel_f = 0.50 }, + { .temperature_c = 55.0, .fanLevel_f = 0.60 }, + { .temperature_c = 60.0, .fanLevel_f = 0.85 }, + { .temperature_c = 65.0, .fanLevel_f = 0.95 }, { .temperature_c = 70.0, .fanLevel_f = 1.00 } }; @@ -135,8 +135,8 @@ void FanControllerThreadFunction(void*) FanController fc; float fanLevelSet_f = 0; float temperatureC_f = 0; - u64 awakeSleepTime = 250000000ULL; // 0.25 second when awake (250ms - responsive) - u64 sleepSleepTime = 5000000000ULL; // 5 seconds when in sleep + u64 awakeSleepTime = 1000000000ULL; // 1 second when awake + u64 sleepSleepTime = 10000000000ULL; // 10 seconds when in sleep int sleepCheckCounter = 0; Result rs = fanOpenController(&fc, 0x3D000001); @@ -148,9 +148,9 @@ void FanControllerThreadFunction(void*) while(!fanControllerThreadExit) { - // Check if system is awake every 20 iterations (~5 seconds) to reduce overhead + // Check if system is awake every 40 iterations (~10 seconds) to reduce overhead sleepCheckCounter++; - if(sleepCheckCounter >= 20) + if(sleepCheckCounter >= 40) { bool isAwake = IsSystemAwake(); sleepCheckCounter = 0; diff --git a/Source/sys-clk/sysmodule/src/fancontrol.h b/Source/sys-clk/sysmodule/src/fancontrol.h index f1f0c67e..d7d16030 100644 --- a/Source/sys-clk/sysmodule/src/fancontrol.h +++ b/Source/sys-clk/sysmodule/src/fancontrol.h @@ -13,10 +13,10 @@ extern "C" { #include #include -#define LOG_DIR "./config/hoc-clk/" -#define LOG_FILE "./config/hoc-clk/fan_log.txt" -#define CONFIG_DIR "./config/hoc-clk/" -#define CONFIG_FILE "./config/hoc-clk/config.dat" +#define LOG_DIR "./config/horizon-oc/" +#define LOG_FILE "./config/horizon-oc/fan_log.txt" +#define CONFIG_DIR "./config/horizon-oc/" +#define CONFIG_FILE "./config/horizon-oc/config.dat" #define TABLE_SIZE sizeof(TemperaturePoint) * 10 diff --git a/Source/sys-clk/sysmodule/src/file_utils.cpp b/Source/sys-clk/sysmodule/src/file_utils.cpp index ceed6a50..675a9f98 100644 --- a/Source/sys-clk/sysmodule/src/file_utils.cpp +++ b/Source/sys-clk/sysmodule/src/file_utils.cpp @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #include "file_utils.h" #include diff --git a/Source/sys-clk/sysmodule/src/file_utils.h b/Source/sys-clk/sysmodule/src/file_utils.h index 681fd9ed..a0c61cf5 100644 --- a/Source/sys-clk/sysmodule/src/file_utils.h +++ b/Source/sys-clk/sysmodule/src/file_utils.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include #include diff --git a/Source/sys-clk/sysmodule/src/ipc_service.cpp b/Source/sys-clk/sysmodule/src/ipc_service.cpp index 47bbdd8b..c1ae6183 100644 --- a/Source/sys-clk/sysmodule/src/ipc_service.cpp +++ b/Source/sys-clk/sysmodule/src/ipc_service.cpp @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,12 +24,15 @@ * -------------------------------------------------------------------------- */ + #include "ipc_service.h" #include #include #include "file_utils.h" #include "errors.h" #include "clock_manager.h" +#include "emc_patcher.h" + IpcService::IpcService(ClockManager* clockMgr) { std::int32_t priority; @@ -145,7 +164,7 @@ Result IpcService::ServiceHandlerFunc(void* arg, const IpcServerRequest* r, u8* break; case SysClkIpcCmd_GetConfigValues: - *out_dataSize = sizeof(SysClkTitleProfileList); + *out_dataSize = sizeof(SysClkConfigValueList); // bug in stock sys-clk. really stupid bug :skull: return ipcSrv->GetConfigValues((SysClkConfigValueList*)out_data); case SysClkIpcCmd_SetConfigValues: @@ -172,6 +191,9 @@ Result IpcService::ServiceHandlerFunc(void* arg, const IpcServerRequest* r, u8* return ipcSrv->SetReverseNXRTMode(mode); } break; + case HocClkIpcCmd_UpdateEMCRegs: // Trigger, not data + return ipcSrv->PatchEmcRegs(); + break; } return SYSCLK_ERROR(Generic); @@ -208,6 +230,7 @@ Result IpcService::Exit() return 0; } + Result IpcService::GetProfileCount(std::uint64_t* tid, std::uint8_t* out_count) { Config* config = this->clockMgr->GetConfig(); @@ -246,7 +269,7 @@ Result IpcService::SetProfiles(SysClkIpc_SetProfiles_Args* args) if(!config->SetProfiles(args->tid, &profiles, true)) { - return SYSCLK_ERROR(ConfigSaveFailed); + return SYSCLK_ERROR(ConfigSaveFailed); // 0x584 } return 0; @@ -328,3 +351,9 @@ Result IpcService::SetReverseNXRTMode(ReverseNXMode mode) { ClockManager::GetInstance()->SetRNXRTMode(mode); return 0; } + + +Result IpcService::PatchEmcRegs() { + EMCpatcher::GetInstance()->Run(); + return 0; +} diff --git a/Source/sys-clk/sysmodule/src/ipc_service.h b/Source/sys-clk/sysmodule/src/ipc_service.h index de74082e..163aa29c 100644 --- a/Source/sys-clk/sysmodule/src/ipc_service.h +++ b/Source/sys-clk/sysmodule/src/ipc_service.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include @@ -37,6 +54,8 @@ class IpcService Result SetConfigValues(SysClkConfigValueList* configValues); Result GetFreqList(SysClkIpc_GetFreqList_Args* args, std::uint32_t* out_list, std::size_t size, std::uint32_t* out_count); Result SetReverseNXRTMode(ReverseNXMode mode); + + Result PatchEmcRegs(); bool running; Thread thread; diff --git a/Source/sys-clk/sysmodule/src/main.cpp b/Source/sys-clk/sysmodule/src/main.cpp index 7c1c6ed5..d9e71919 100644 --- a/Source/sys-clk/sysmodule/src/main.cpp +++ b/Source/sys-clk/sysmodule/src/main.cpp @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #include #include #include @@ -21,7 +38,9 @@ #include "clock_manager.h" #include "ipc_service.h" #include "fancontrol.h" -#define INNER_HEAP_SIZE 0x30000 +#include "emc_patcher.h" + +#define INNER_HEAP_SIZE 0x50000 extern "C" { @@ -49,12 +68,22 @@ extern "C" void __appInit(void) { + Result rc; if (R_FAILED(smInitialize())) { fatalThrow(MAKERESULT(Module_Libnx, LibnxError_InitFail_SM)); } - Result rc = setsysInitialize(); + rc = fanInitialize(); + if (R_FAILED(rc)) + diagAbortWithResult(MAKERESULT(Module_Libnx, LibnxError_ShouldNotHappen)); + + rc = i2cInitialize(); + if (R_FAILED(rc)) + diagAbortWithResult(MAKERESULT(Module_Libnx, LibnxError_ShouldNotHappen)); + + + rc = setsysInitialize(); if (R_SUCCEEDED(rc)) { SetSysFirmwareVersion fw; @@ -63,14 +92,7 @@ extern "C" hosversionSet(MAKEHOSVERSION(fw.major, fw.minor, fw.micro)); setsysExit(); } - - rc = fanInitialize(); - if (R_FAILED(rc)) - diagAbortWithResult(MAKERESULT(Module_Libnx, LibnxError_ShouldNotHappen)); - - rc = i2cInitialize(); - if (R_FAILED(rc)) - diagAbortWithResult(MAKERESULT(Module_Libnx, LibnxError_ShouldNotHappen)); + } void __appExit(void) @@ -79,7 +101,8 @@ extern "C" fanExit(); i2cExit(); fsExit(); - fsdevUnmountAll(); + fsdevUnmountAll(); + smExit(); } } @@ -102,7 +125,7 @@ int main(int argc, char** argv) ClockManager* clockMgr = new ClockManager(); IpcService* ipcSrv = new IpcService(clockMgr); - FileUtils::LogLine("Ready"); + FileUtils::LogLine("Starting Horizon OC Sysmodule"); clockMgr->SetRunning(true); clockMgr->GetConfig()->SetEnabled(true); diff --git a/Source/sys-clk/sysmodule/src/maxXXXXX.h b/Source/sys-clk/sysmodule/src/maxXXXXX.h new file mode 100644 index 00000000..2da06670 --- /dev/null +++ b/Source/sys-clk/sysmodule/src/maxXXXXX.h @@ -0,0 +1,691 @@ +/* + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + + +/* + * Defining registers address and its bit definitions of MAX77620 and MAX20024 + * + * Copyright (c) 2019-2020 CTCaer + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + */ + +#include + +#ifndef MAX77XXX_H +#define MAX77XXX_H + + +#define MAX17050_BOARD_CGAIN 2 /* Actual: 1.99993 */ +#define MAX17050_BOARD_SNS_RESISTOR_UOHM 5000 /* 0.005 Ohm */ + +#define MAX17050_STATUS_BattAbsent BIT(3) + +/* Consider RepCap which is less then 10 units below FullCAP full */ +#define MAX17050_FULL_THRESHOLD 10 + +#define MAX17050_CHARACTERIZATION_DATA_SIZE 48 + +#define MAXIM17050_I2C_ADDR 0x36 + +enum MAX17050_reg { + MAX17050_STATUS = 0x00, + MAX17050_VALRT_Th = 0x01, + MAX17050_TALRT_Th = 0x02, + MAX17050_SALRT_Th = 0x03, + MAX17050_AtRate = 0x04, + MAX17050_RepCap = 0x05, + MAX17050_RepSOC = 0x06, + MAX17050_Age = 0x07, + MAX17050_TEMP = 0x08, + MAX17050_VCELL = 0x09, + MAX17050_Current = 0x0A, + MAX17050_AvgCurrent = 0x0B, + + MAX17050_SOC = 0x0D, + MAX17050_AvSOC = 0x0E, + MAX17050_RemCap = 0x0F, + MAX17050_FullCAP = 0x10, + MAX17050_TTE = 0x11, + MAX17050_QRTbl00 = 0x12, + MAX17050_FullSOCThr = 0x13, + MAX17050_RSLOW = 0x14, + + MAX17050_AvgTA = 0x16, + MAX17050_Cycles = 0x17, + MAX17050_DesignCap = 0x18, + MAX17050_AvgVCELL = 0x19, + MAX17050_MinMaxTemp = 0x1A, + MAX17050_MinMaxVolt = 0x1B, + MAX17050_MinMaxCurr = 0x1C, + MAX17050_CONFIG = 0x1D, + MAX17050_ICHGTerm = 0x1E, + MAX17050_AvCap = 0x1F, + MAX17050_ManName = 0x20, + MAX17050_DevName = 0x21, + MAX17050_QRTbl10 = 0x22, + MAX17050_FullCAPNom = 0x23, + MAX17050_TempNom = 0x24, + MAX17050_TempLim = 0x25, + MAX17050_TempHot = 0x26, + MAX17050_AIN = 0x27, + MAX17050_LearnCFG = 0x28, + MAX17050_FilterCFG = 0x29, + MAX17050_RelaxCFG = 0x2A, + MAX17050_MiscCFG = 0x2B, + MAX17050_TGAIN = 0x2C, + MAX17050_TOFF = 0x2D, + MAX17050_CGAIN = 0x2E, + MAX17050_COFF = 0x2F, + + MAX17050_QRTbl20 = 0x32, + MAX17050_SOC_empty = 0x33, + MAX17050_T_empty = 0x34, + MAX17050_FullCAP0 = 0x35, + MAX17050_LAvg_empty = 0x36, + MAX17050_FCTC = 0x37, + MAX17050_RCOMP0 = 0x38, + MAX17050_TempCo = 0x39, + MAX17050_V_empty = 0x3A, + MAX17050_K_empty0 = 0x3B, + MAX17050_TaskPeriod = 0x3C, + MAX17050_FSTAT = 0x3D, + MAX17050_TIMER = 0x3E, + MAX17050_SHDNTIMER = 0x3F, + + MAX17050_QRTbl30 = 0x42, + + MAX17050_dQacc = 0x45, + MAX17050_dPacc = 0x46, + + MAX17050_VFSOC0 = 0x48, + + Max17050_QH0 = 0x4C, + MAX17050_QH = 0x4D, + MAX17050_QL = 0x4E, + + MAX17050_MinVolt = 0x50, // Custom ID. Not to be sent to i2c. + MAX17050_MaxVolt = 0x51, // Custom ID. Not to be sent to i2c. + + MAX17050_VFSOC0Enable = 0x60, + MAX17050_MODELEnable1 = 0x62, + MAX17050_MODELEnable2 = 0x63, + + MAX17050_MODELChrTbl = 0x80, + + MAX17050_OCV = 0xEE, + + MAX17050_OCVInternal = 0xFB, + + MAX17050_VFSOC = 0xFF, +}; + +#define MAX77620_I2C_ADDR 0x3C + +/* GLOBAL, PMIC, GPIO, FPS, ONOFFC, CID Registers */ +#define MAX77620_REG_CNFGGLBL1 0x00 +#define MAX77620_CNFGGLBL1_LBRSTEN BIT(0) +#define MAX77620_CNFGGLBL1_LBDAC_MASK 0x0E +#define MAX77620_CNFGGLBL1_LBDAC_2700 (0 << 1) +#define MAX77620_CNFGGLBL1_LBDAC_2800 (1 << 1) +#define MAX77620_CNFGGLBL1_LBDAC_2900 (2 << 1) +#define MAX77620_CNFGGLBL1_LBDAC_3000 (3 << 1) +#define MAX77620_CNFGGLBL1_LBDAC_3100 (4 << 1) +#define MAX77620_CNFGGLBL1_LBDAC_3200 (5 << 1) +#define MAX77620_CNFGGLBL1_LBDAC_3300 (6 << 1) +#define MAX77620_CNFGGLBL1_LBDAC_3400 (7 << 1) +#define MAX77620_CNFGGLBL1_LBHYST_100 (0 << 4) +#define MAX77620_CNFGGLBL1_LBHYST_200 (1 << 4) +#define MAX77620_CNFGGLBL1_LBHYST_300 (2 << 4) +#define MAX77620_CNFGGLBL1_LBHYST_400 (3 << 4) +#define MAX77620_CNFGGLBL1_MPPLD BIT(6) +#define MAX77620_CNFGGLBL1_LBDAC_EN BIT(7) + +#define MAX77620_REG_CNFGGLBL2 0x01 +#define MAX77620_TWD_MASK 0x3 +#define MAX77620_TWD_2s 0x0 +#define MAX77620_TWD_16s 0x1 +#define MAX77620_TWD_64s 0x2 +#define MAX77620_TWD_128s 0x3 +#define MAX77620_WDTEN BIT(2) +#define MAX77620_WDTSLPC BIT(3) +#define MAX77620_WDTOFFC BIT(4) +#define MAX77620_GLBL_LPM BIT(5) +#define MAX77620_I2CTWD_MASK 0xC0 +#define MAX77620_I2CTWD_DISABLED 0x00 +#define MAX77620_I2CTWD_1_33ms 0x40 +#define MAX77620_I2CTWD_35_7ms 0x80 +#define MAX77620_I2CTWD_41_7ms 0xC0 + +#define MAX77620_REG_CNFGGLBL3 0x02 +#define MAX77620_WDTC_MASK 0x3 + +#define MAX77620_REG_CNFG1_32K 0x03 +#define MAX77620_CNFG1_PWR_MD_32K_MASK 0x3 +#define MAX77620_CNFG1_32K_OUT0_EN BIT(2) +#define MAX77620_CNFG1_32KLOAD_MASK 0x30 +#define MAX77620_CNFG1_32K_OK BIT(7) + +#define MAX77620_REG_CNFGBBC 0x04 +#define MAX77620_CNFGBBC_ENABLE BIT(0) +#define MAX77620_CNFGBBC_CURRENT_MASK 0x06 +#define MAX77620_CNFGBBC_CURRENT_SHIFT 1 +#define MAX77620_CNFGBBC_VOLTAGE_MASK 0x18 +#define MAX77620_CNFGBBC_VOLTAGE_SHIFT 3 +#define MAX77620_CNFGBBC_LOW_CURRENT_DISABLE BIT(5) +#define MAX77620_CNFGBBC_RESISTOR_MASK 0xC0 +#define MAX77620_CNFGBBC_RESISTOR_SHIFT 6 +#define MAX77620_CNFGBBC_RESISTOR_100 (0 << MAX77620_CNFGBBC_RESISTOR_SHIFT) +#define MAX77620_CNFGBBC_RESISTOR_1K (1 << MAX77620_CNFGBBC_RESISTOR_SHIFT) +#define MAX77620_CNFGBBC_RESISTOR_3K (2 << MAX77620_CNFGBBC_RESISTOR_SHIFT) +#define MAX77620_CNFGBBC_RESISTOR_6K (3 << MAX77620_CNFGBBC_RESISTOR_SHIFT) + +#define MAX77620_REG_IRQTOP 0x05 +#define MAX77620_REG_IRQTOPM 0x0D +#define MAX77620_IRQ_TOP_ONOFF_MASK BIT(1) +#define MAX77620_IRQ_TOP_32K_MASK BIT(2) +#define MAX77620_IRQ_TOP_RTC_MASK BIT(3) +#define MAX77620_IRQ_TOP_GPIO_MASK BIT(4) +#define MAX77620_IRQ_TOP_LDO_MASK BIT(5) +#define MAX77620_IRQ_TOP_SD_MASK BIT(6) +#define MAX77620_IRQ_TOP_GLBL_MASK BIT(7) + +#define MAX77620_REG_INTLBT 0x06 +#define MAX77620_REG_INTENLBT 0x0E +#define MAX77620_IRQ_GLBLM_MASK BIT(0) +#define MAX77620_IRQ_TJALRM2_MASK BIT(1) +#define MAX77620_IRQ_TJALRM1_MASK BIT(2) +#define MAX77620_IRQ_LBM_MASK BIT(3) + +#define MAX77620_REG_IRQSD 0x07 +#define MAX77620_REG_IRQMASKSD 0x0F +#define MAX77620_IRQSD_PFI_SD3 BIT(4) +#define MAX77620_IRQSD_PFI_SD2 BIT(5) +#define MAX77620_IRQSD_PFI_SD1 BIT(6) +#define MAX77620_IRQSD_PFI_SD0 BIT(7) + +#define MAX77620_REG_IRQ_LVL2_L0_7 0x08 // LDO number that irq occurred. +#define MAX77620_REG_IRQ_MSK_L0_7 0x10 +#define MAX77620_REG_IRQ_LVL2_L8 \ + 0x09 // LDO number that irq occurred. Only bit0: LDO8 is valid. +#define MAX77620_REG_IRQ_MSK_L8 0x11 +#define MAX77620_REG_IRQ_LVL2_GPIO 0x0A // Edge detection interrupt. + +#define MAX77620_REG_ONOFFIRQ 0x0B +#define MAX77620_REG_ONOFFIRQM 0x12 +#define MAX77620_ONOFFIRQ_MRWRN BIT(0) +#define MAX77620_ONOFFIRQ_EN0_1SEC BIT(1) +#define MAX77620_ONOFFIRQ_EN0_F BIT(2) +#define MAX77620_ONOFFIRQ_EN0_R BIT(3) +#define MAX77620_ONOFFIRQ_LID_F BIT(4) +#define MAX77620_ONOFFIRQ_LID_R BIT(5) +#define MAX77620_ONOFFIRQ_ACOK_F BIT(6) +#define MAX77620_ONOFFIRQ_ACOK_R BIT(7) + +#define MAX77620_REG_NVERC 0x0C // Shutdown reason (non-volatile). +#define MAX77620_NVERC_SHDN BIT(0) +#define MAX77620_NVERC_WTCHDG BIT(1) +#define MAX77620_NVERC_HDRST BIT(2) +#define MAX77620_NVERC_TOVLD BIT(3) +#define MAX77620_NVERC_MBLSD BIT(4) +#define MAX77620_NVERC_MBO BIT(5) +#define MAX77620_NVERC_MBU BIT(6) +#define MAX77620_NVERC_RSTIN BIT(7) + +#define MAX77620_REG_STATLBT 0x13 +#define MAX77620_REG_STATSD 0x14 + +#define MAX77620_REG_ONOFFSTAT 0x15 +#define MAX77620_ONOFFSTAT_LID BIT(0) +#define MAX77620_ONOFFSTAT_ACOK BIT(1) +#define MAX77620_ONOFFSTAT_EN0 BIT(2) + +/* SD and LDO Registers */ +#define MAX77620_REG_SD0 0x16 +#define MAX77620_REG_SD1 0x17 +#define MAX77620_REG_SD2 0x18 +#define MAX77620_REG_SD3 0x19 +#define MAX77620_REG_SD4 0x1A +#define MAX77620_REG_DVSSD0 0x1B +#define MAX77620_REG_DVSSD1 0x1C +#define MAX77620_SDX_VOLT_MASK 0xFF +#define MAX77620_SD0_VOLT_MASK 0x7F // Max is 0x40. +#define MAX77620_SD1_VOLT_MASK 0x7F // Max is 0x4C. +#define MAX77620_LDO_VOLT_MASK 0x3F + +#define MAX77620_REG_SD0_CFG 0x1D +#define MAX77620_REG_SD1_CFG 0x1E +#define MAX77620_REG_SD2_CFG 0x1F +#define MAX77620_REG_SD3_CFG 0x20 +#define MAX77620_REG_SD4_CFG 0x21 +#define MAX77620_SD_SR_MASK 0xC0 +#define MAX77620_SD_SR_SHIFT 6 +#define MAX77620_SD_POWER_MODE_MASK 0x30 +#define MAX77620_SD_POWER_MODE_SHIFT 4 +#define MAX77620_SD_CFG1_ADE_MASK BIT(3) +#define MAX77620_SD_CFG1_ADE_DISABLE 0 +#define MAX77620_SD_CFG1_ADE_ENABLE BIT(3) +#define MAX77620_SD_FPWM_MASK 0x04 +#define MAX77620_SD_FPWM_SHIFT 2 +#define MAX77620_SD_FSRADE_MASK 0x01 +#define MAX77620_SD_FSRADE_SHIFT 0 +#define MAX77620_SD_CFG1_FPWM_SD_MASK BIT(2) +#define MAX77620_SD_CFG1_FPWM_SD_SKIP 0 +#define MAX77620_SD_CFG1_FPWM_SD_FPWM BIT(2) +#define MAX77620_SD_CFG1_MPOK_MASK BIT(1) +#define MAX77620_SD_CFG1_FSRADE_SD_MASK BIT(0) +#define MAX77620_SD_CFG1_FSRADE_SD_DISABLE 0 +#define MAX77620_SD_CFG1_FSRADE_SD_ENABLE BIT(0) + +#define MAX77620_REG_SD_CFG2 0x22 +#define MAX77620_SD_CNF2_RSVD BIT(0) +#define MAX77620_SD_CNF2_ROVS_EN_SD1 BIT(1) +#define MAX77620_SD_CNF2_ROVS_EN_SD0 BIT(2) + +#define MAX77620_REG_LDO0_CFG 0x23 +#define MAX77620_REG_LDO0_CFG2 0x24 +#define MAX77620_REG_LDO1_CFG 0x25 +#define MAX77620_REG_LDO1_CFG2 0x26 +#define MAX77620_REG_LDO2_CFG 0x27 +#define MAX77620_REG_LDO2_CFG2 0x28 +#define MAX77620_REG_LDO3_CFG 0x29 +#define MAX77620_REG_LDO3_CFG2 0x2A +#define MAX77620_REG_LDO4_CFG 0x2B +#define MAX77620_REG_LDO4_CFG2 0x2C +#define MAX77620_REG_LDO5_CFG 0x2D +#define MAX77620_REG_LDO5_CFG2 0x2E +#define MAX77620_REG_LDO6_CFG 0x2F +#define MAX77620_REG_LDO6_CFG2 0x30 +#define MAX77620_REG_LDO7_CFG 0x31 +#define MAX77620_REG_LDO7_CFG2 0x32 +#define MAX77620_REG_LDO8_CFG 0x33 +#define MAX77620_REG_LDO8_CFG2 0x34 +/*! LDO CFG */ +#define MAX77620_LDO_POWER_MODE_SHIFT 6 +#define MAX77620_LDO_POWER_MODE_MASK (3 << MAX77620_LDO_POWER_MODE_SHIFT) +#define MAX77620_POWER_MODE_NORMAL 3 +#define MAX77620_POWER_MODE_LPM 2 +#define MAX77620_POWER_MODE_GLPM 1 +#define MAX77620_POWER_MODE_DISABLE 0 +/*! LDO CFG2 */ +#define MAX77620_LDO_CFG2_SS_MASK (1 << 0) +#define MAX77620_LDO_CFG2_SS_FAST (0 << 0) +#define MAX77620_LDO_CFG2_SS_SLOW (1 << 0) +#define MAX77620_LDO_CFG2_ADE_MASK (1 << 1) +#define MAX77620_LDO_CFG2_ADE_DISABLE (0 << 1) +#define MAX77620_LDO_CFG2_ADE_ENABLE (1 << 1) +#define MAX77620_LDO_CFG2_MPOK_MASK BIT(2) +#define MAX77620_LDO_CFG2_POK_MASK BIT(3) +#define MAX77620_LDO_CFG2_COMP_SHIFT 4 +#define MAX77620_LDO_CFG2_COMP_MASK (3 << MAX77620_LDO_COMP_SHIFT) +#define MAX77620_LDO_CFG2_COMP_SLOW 3 +#define MAX77620_LDO_CFG2_COMP_MID_SLOW 2 +#define MAX77620_LDO_CFG2_COMP_MID_FAST 1 +#define MAX77620_LDO_CFG2_COMP_FAST 0 +#define MAX77620_LDO_CFG2_ALPM_EN_MASK BIT(6) +#define MAX77620_LDO_CFG2_OVCLMP_MASK BIT(7) + +#define MAX77620_REG_LDO_CFG3 0x35 +#define MAX77620_LDO_BIAS_EN BIT(0) +#define MAX77620_TRACK4_SHIFT 5 +#define MAX77620_TRACK4_MASK (1 << MAX77620_TRACK4_SHIFT) + +#define MAX77620_REG_GPIO0 0x36 +#define MAX77620_REG_GPIO1 0x37 +#define MAX77620_REG_GPIO2 0x38 +#define MAX77620_REG_GPIO3 0x39 +#define MAX77620_REG_GPIO4 0x3A +#define MAX77620_REG_GPIO5 0x3B +#define MAX77620_REG_GPIO6 0x3C +#define MAX77620_REG_GPIO7 0x3D +#define MAX77620_CNFG_GPIO_DRV_MASK (1 << 0) +#define MAX77620_CNFG_GPIO_DRV_PUSHPULL (1 << 0) +#define MAX77620_CNFG_GPIO_DRV_OPENDRAIN (0 << 0) +#define MAX77620_CNFG_GPIO_DIR_MASK (1 << 1) +#define MAX77620_CNFG_GPIO_DIR_INPUT (1 << 1) +#define MAX77620_CNFG_GPIO_DIR_OUTPUT (0 << 1) +#define MAX77620_CNFG_GPIO_INPUT_VAL_MASK (1 << 2) +#define MAX77620_CNFG_GPIO_OUTPUT_VAL_MASK (1 << 3) +#define MAX77620_CNFG_GPIO_OUTPUT_VAL_HIGH (1 << 3) +#define MAX77620_CNFG_GPIO_OUTPUT_VAL_LOW (0 << 3) +#define MAX77620_CNFG_GPIO_INT_MASK (0x3 << 4) +#define MAX77620_CNFG_GPIO_INT_FALLING (1 << 4) +#define MAX77620_CNFG_GPIO_INT_RISING (1 << 5) +#define MAX77620_CNFG_GPIO_DBNC_MASK (0x3 << 6) +#define MAX77620_CNFG_GPIO_DBNC_None (0x0 << 6) +#define MAX77620_CNFG_GPIO_DBNC_8ms (0x1 << 6) +#define MAX77620_CNFG_GPIO_DBNC_16ms (0x2 << 6) +#define MAX77620_CNFG_GPIO_DBNC_32ms (0x3 << 6) +#define MAX77620_GPIO_OUTPUT_DISABLE 0 +#define MAX77620_GPIO_OUTPUT_ENABLE 1 + +#define MAX77620_REG_PUE_GPIO 0x3E // Gpio Pullup resistor enable. +#define MAX77620_REG_PDE_GPIO 0x3F // Gpio Pulldown resistor enable. + +#define MAX77620_REG_AME_GPIO \ + 0x40 // Gpio pinmuxing. Clear bits are Standard GPIO. + +#define MAX77620_REG_ONOFFCNFG1 0x41 +#define MAX20024_ONOFFCNFG1_CLRSE 0x18 +#define MAX77620_ONOFFCNFG1_PWR_OFF BIT(1) +#define MAX77620_ONOFFCNFG1_SLPEN BIT(2) +#define MAX77620_ONOFFCNFG1_MRT_SHIFT 0x3 +#define MAX77620_ONOFFCNFG1_MRT_MASK 0x38 +#define MAX77620_ONOFFCNFG1_RSVD BIT(6) +#define MAX77620_ONOFFCNFG1_SFT_RST BIT(7) + +#define MAX77620_REG_ONOFFCNFG2 0x42 +#define MAX77620_ONOFFCNFG2_WK_EN0 BIT(0) +#define MAX77620_ONOFFCNFG2_WK_ALARM2 BIT(1) +#define MAX77620_ONOFFCNFG2_WK_ALARM1 BIT(2) +#define MAX77620_ONOFFCNFG2_WK_MBATT \ + BIT(3) // MBATT event generates a wakeup signal. use it in android/l4t? +#define MAX77620_ONOFFCNFG2_WK_ACOK BIT(4) +#define MAX77620_ONOFFCNFG2_SLP_LPM_MSK BIT(5) +#define MAX77620_ONOFFCNFG2_WD_RST_WK BIT(6) +#define MAX77620_ONOFFCNFG2_SFT_RST_WK BIT(7) + +/* FPS Registers */ +#define MAX77620_REG_FPS_CFG0 0x43 // FPS0. +#define MAX77620_REG_FPS_CFG1 0x44 // FPS1. +#define MAX77620_REG_FPS_CFG2 0x45 // FPS2. +#define MAX77620_FPS_ENFPS_SW_MASK 0x01 +#define MAX77620_FPS_ENFPS_SW 0x01 +#define MAX77620_FPS_EN_SRC_SHIFT 1 +#define MAX77620_FPS_EN_SRC_MASK 0x06 +#define MAX77620_FPS_TIME_PERIOD_SHIFT 3 +#define MAX77620_FPS_TIME_PERIOD_MASK 0x38 + +#define MAX77620_REG_FPS_LDO0 0x46 +#define MAX77620_REG_FPS_LDO1 0x47 +#define MAX77620_REG_FPS_LDO2 0x48 +#define MAX77620_REG_FPS_LDO3 0x49 +#define MAX77620_REG_FPS_LDO4 0x4A +#define MAX77620_REG_FPS_LDO5 0x4B +#define MAX77620_REG_FPS_LDO6 0x4C +#define MAX77620_REG_FPS_LDO7 0x4D +#define MAX77620_REG_FPS_LDO8 0x4E +#define MAX77620_REG_FPS_SD0 0x4F +#define MAX77620_REG_FPS_SD1 0x50 +#define MAX77620_REG_FPS_SD2 0x51 +#define MAX77620_REG_FPS_SD3 0x52 +#define MAX77620_REG_FPS_SD4 0x53 +#define MAX77620_REG_FPS_GPIO1 0x54 +#define MAX77620_REG_FPS_GPIO2 0x55 +#define MAX77620_REG_FPS_GPIO3 0x56 +#define MAX77620_REG_FPS_RSO 0x57 +#define MAX77620_FPS_PD_PERIOD_SHIFT 0 +#define MAX77620_FPS_PD_PERIOD_MASK 0x07 +#define MAX77620_FPS_PU_PERIOD_SHIFT 3 +#define MAX77620_FPS_PU_PERIOD_MASK 0x38 +#define MAX77620_FPS_SRC_SHIFT 6 +#define MAX77620_FPS_SRC_MASK 0xC0 + +#define MAX77620_FPS_COUNT 3 +#define MAX77620_FPS_PERIOD_MIN_US 40 +#define MAX77620_FPS_PERIOD_MAX_US 2560 + +#define MAX77620_REG_CID0 0x58 +#define MAX77620_REG_CID1 0x59 +#define MAX77620_REG_CID2 0x5A +#define MAX77620_REG_CID3 0x5B +#define MAX77620_REG_CID4 0x5C // OTP version. +#define MAX77620_REG_CID5 0x5D // ES version. +#define MAX77620_CID_DIDO_MASK 0xF +#define MAX77620_CID_DIDO_SHIFT 0 +#define MAX77620_CID_DIDM_MASK 0xF0 +#define MAX77620_CID_DIDM_SHIFT 4 + +/* Device Identification Metal */ +#define MAX77620_CID5_DIDM(n) (((n) >> 4) & 0xF) +/* Device Indentification OTP */ +#define MAX77620_CID5_DIDO(n) ((n) & 0xF) + +#define MAX77620_REG_DVSSD4 0x5E +#define MAX20024_REG_MAX_ADD 0x70 + +#define MAX77620_IRQ_LVL2_GPIO_EDGE0 BIT(0) +#define MAX77620_IRQ_LVL2_GPIO_EDGE1 BIT(1) +#define MAX77620_IRQ_LVL2_GPIO_EDGE2 BIT(2) +#define MAX77620_IRQ_LVL2_GPIO_EDGE3 BIT(3) +#define MAX77620_IRQ_LVL2_GPIO_EDGE4 BIT(4) +#define MAX77620_IRQ_LVL2_GPIO_EDGE5 BIT(5) +#define MAX77620_IRQ_LVL2_GPIO_EDGE6 BIT(6) +#define MAX77620_IRQ_LVL2_GPIO_EDGE7 BIT(7) + +/* Interrupts */ +enum { + MAX77620_IRQ_TOP_GLBL, /* Low-Battery */ + MAX77620_IRQ_TOP_SD, /* SD power fail */ + MAX77620_IRQ_TOP_LDO, /* LDO power fail */ + MAX77620_IRQ_TOP_GPIO, /* TOP GPIO internal int to MAX77620 */ + MAX77620_IRQ_TOP_RTC, /* RTC */ + MAX77620_IRQ_TOP_32K, /* 32kHz oscillator */ + MAX77620_IRQ_TOP_ONOFF, /* ON/OFF oscillator */ + MAX77620_IRQ_LBT_MBATLOW, /* Thermal alarm status, > 120C */ + MAX77620_IRQ_LBT_TJALRM1, /* Thermal alarm status, > 120C */ + MAX77620_IRQ_LBT_TJALRM2, /* Thermal alarm status, > 140C */ +}; + +/* GPIOs */ +enum { + MAX77620_GPIO0, + MAX77620_GPIO1, + MAX77620_GPIO2, + MAX77620_GPIO3, + MAX77620_GPIO4, + MAX77620_GPIO5, + MAX77620_GPIO6, + MAX77620_GPIO7, + MAX77620_GPIO_NR, +}; + +/* FPS Source */ +enum max77620_fps_src { + MAX77620_FPS_SRC_0, + MAX77620_FPS_SRC_1, + MAX77620_FPS_SRC_2, + MAX77620_FPS_SRC_NONE, + MAX77620_FPS_SRC_DEF, +}; + +#define MAX77812_PHASE31_CPU_I2C_ADDR \ + 0x31 // High power GPU. 2 Outputs: 3-phase M1 + 1-phase M4. +#define MAX77812_PHASE211_CPU_I2C_ADDR \ + 0x33 // Low power GPU. 3 Outputs: 2-phase M1 + 1-phase M3 + 1-phase M4. + +#define MAX77812_REG_RSET 0x00 +#define MAX77812_REG_INT_SRC 0x01 +#define MAX77812_REG_INT_SRC_M 0x02 +#define MAX77812_REG_TOPSYS_INT 0x03 +#define MAX77812_REG_TOPSYS_INT_M 0x04 +#define MAX77812_REG_TOPSYS_STAT 0x05 +#define MAX77812_REG_EN_CTRL 0x06 +#define MAX77812_EN_CTRL_ENABLE 1 +#define MAX77812_EN_CTRL_EN_M1_SHIFT 0 +#define MAX77812_EN_CTRL_EN_M1_MASK (1 << MAX77812_EN_CTRL_EN_M1_SHIFT) +#define MAX77812_EN_CTRL_EN_M2_SHIFT 2 +#define MAX77812_EN_CTRL_EN_M2_MASK (1 << MAX77812_EN_CTRL_EN_M2_SHIFT) +#define MAX77812_EN_CTRL_EN_M3_SHIFT 4 +#define MAX77812_EN_CTRL_EN_M3_MASK (1 << MAX77812_EN_CTRL_EN_M3_SHIFT) +#define MAX77812_EN_CTRL_EN_M4_SHIFT 6 +#define MAX77812_EN_CTRL_EN_M4_MASK (1 << MAX77812_EN_CTRL_EN_M4_SHIFT) +#define MAX77812_REG_STUP_DLY2 0x07 +#define MAX77812_REG_STUP_DLY3 0x08 +#define MAX77812_REG_STUP_DLY4 0x09 +#define MAX77812_REG_SHDN_DLY1 0x0A +#define MAX77812_REG_SHDN_DLY2 0x0B +#define MAX77812_REG_SHDN_DLY3 0x0C +#define MAX77812_REG_SHDN_DLY4 0x0D +#define MAX77812_REG_WDTRSTB_DEB 0x0E +#define MAX77812_REG_GPI_FUNC 0x0F +#define MAX77812_REG_GPI_DEB1 0x10 +#define MAX77812_REG_GPI_DEB2 0x11 +#define MAX77812_REG_GPI_PD_CTRL 0x12 +#define MAX77812_REG_PROT_CFG 0x13 +#define MAX77812_REG_VERSION 0x14 +#define MAX77812_REG_I2C_CFG 0x15 +#define MAX77812_REG_BUCK_INT 0x20 +#define MAX77812_REG_BUCK_INT_M 0x21 +#define MAX77812_REG_BUCK_STAT 0x22 +#define MAX77812_REG_M1_VOUT 0x23 // GPU. +#define MAX77812_REG_M2_VOUT 0x24 +#define MAX77812_REG_M3_VOUT 0x25 // DRAM on PHASE211. +#define MAX77812_REG_M4_VOUT 0x26 // CPU. +#define MAX77812_REG_M1_VOUT_D 0x27 +#define MAX77812_REG_M2_VOUT_D 0x28 +#define MAX77812_REG_M3_VOUT_D 0x29 +#define MAX77812_REG_M4_VOUT_D 0x2A +#define MAX77812_REG_M1_VOUT_S 0x2B +#define MAX77812_REG_M2_VOUT_S 0x2C +#define MAX77812_REG_M3_VOUT_S 0x2D +#define MAX77812_REG_M4_VOUT_S 0x2E +#define MAX77812_REG_M1_CFG 0x2F // HOS: M1_ILIM - 7.2A/4.8A. +#define MAX77812_REG_M2_CFG 0x30 // HOS: M2_ILIM - 7.2A/4.8A. +#define MAX77812_REG_M3_CFG 0x31 // HOS: M3_ILIM - 7.2A/4.8A. +#define MAX77812_REG_M4_CFG 0x32 // HOS: M4_ILIM - 7.2A/4.8A. +#define MAX77812_REG_GLB_CFG1 0x33 // HOS: B_SD_SR/B_SS_SR - 5mV/us. +#define MAX77812_REG_GLB_CFG2 0x34 // HOS: B_RD_SR/B_RU_SR - 5mV/us +#define MAX77812_REG_GLB_CFG3 0x35 + +/*! Protected area and settings only for MAX77812_ES2_VERSION */ +#define MAX77812_REG_GLB_CFG4 0x36 // QS: 0xBB. +#define MAX77812_REG_GLB_CFG5 0x37 // QS: 0x39. ES2: Set to 0x3E. +#define MAX77812_REG_GLB_CFG6 0x38 // QS: 0x88. ES2: Set to 0x90. +#define MAX77812_REG_GLB_CFG7 0x39 // QS: 0x04. +#define MAX77812_REG_GLB_CFG8 0x3A // QS: 0x3A. ES2: Set to 0x3A. + +#define MAX77812_REG_PROT_ACCESS 0xFD // 0x00: Lock, 0x5A: Unlock. +#define MAX77812_REG_UNKNOWN 0xFE + +#define MAX77812_REG_EN_CTRL_MASK(n) BIT(n) +#define MAX77812_START_SLEW_RATE_MASK 0x07 +#define MAX77812_SHDN_SLEW_RATE_MASK 0x70 +#define MAX77812_RAMPUP_SLEW_RATE_MASK 0x07 +#define MAX77812_RAMPDOWN_SLEW_RATE_MASK 0x70 +#define MAX77812_SLEW_RATE_SHIFT 4 + +#define MAX77812_OP_ACTIVE_DISCHARGE_MASK BIT(7) +#define MAX77812_PEAK_CURRENT_LMT_MASK 0x70 +#define MAX77812_SWITCH_FREQ_MASK 0x0C +#define MAX77812_FORCED_PWM_MASK BIT(1) +#define MAX77812_SLEW_RATE_CNTRL_MASK BIT(0) +#define MAX77812_START_SHD_DELAY_MASK 0x1F +#define MAX77812_VERSION_MASK 0x07 +#define MAX77812_ES2_VERSION 0x04 +#define MAX77812_QS_VERSION 0x05 + +#define MAX77812_BUCK_VOLT_MASK 0xFF + +#define BQ24193_I2C_ADDR 0x6B + +// REG 0 masks. +#define BQ24193_INCONFIG_INLIMIT_MASK (7 << 0) +#define BQ24193_INCONFIG_VINDPM_MASK 0x78 +#define BQ24193_INCONFIG_HIZ_EN_MASK (1 << 7) + +// REG 1 masks. +#define BQ24193_PORCONFIG_BOOST_MASK (1 << 0) +#define BQ24193_PORCONFIG_SYSMIN_MASK (7 << 1) // 3000uV HOS default. +#define BQ24193_PORCONFIG_CHGCONFIG_MASK (3 << 4) +#define BQ24193_PORCONFIG_CHGCONFIG_CHARGER_EN (1 << 4) +#define BQ24193_PORCONFIG_I2CWATCHDOG_MASK (1 << 6) +#define BQ24193_PORCONFIG_RESET_MASK (1 << 7) + +// REG 2 masks. +#define BQ24193_CHRGCURR_20PCT_MASK (1 << 0) +#define BQ24193_CHRGCURR_ICHG_MASK 0xFC + +// REG 3 masks. +#define BQ24193_PRECHRG_ITERM 0x0F +#define BQ24193_PRECHRG_IPRECHG 0xF0 + +// REG 4 masks. +#define BQ24193_CHRGVOLT_VTHRES (1 << 0) +#define BQ24193_CHRGVOLT_BATTLOW (1 << 1) +#define BQ24193_CHRGVOLT_VREG 0xFC + +// REG 5 masks. +#define BQ24193_CHRGTERM_ISET_MASK (1 << 0) +#define BQ24193_CHRGTERM_CHGTIMER_MASK (3 << 1) +#define BQ24193_CHRGTERM_ENTIMER_MASK (1 << 3) +#define BQ24193_CHRGTERM_WATCHDOG_MASK (3 << 4) +#define BQ24193_CHRGTERM_TERM_ST_MASK (1 << 6) +#define BQ24193_CHRGTERM_TERM_EN_MASK (1 << 7) + +// REG 6 masks. +#define BQ24193_IRTHERMAL_THERM_MASK (3 << 0) +#define BQ24193_IRTHERMAL_VCLAMP_MASK (7 << 2) +#define BQ24193_IRTHERMAL_BATTCOMP_MASK (7 << 5) + +// REG 7 masks. +#define BQ24193_MISC_INT_MASK (3 << 0) +#define BQ24193_MISC_VSET_MASK (1 << 4) +#define BQ24193_MISC_BATFET_DI_MASK (1 << 5) +#define BQ24193_MISC_TMR2X_EN_MASK (1 << 6) +#define BQ24193_MISC_DPDM_EN_MASK (1 << 7) + +// REG 8 masks. +#define BQ24193_STATUS_VSYS_MASK (1 << 0) +#define BQ24193_STATUS_THERM_MASK (1 << 1) +#define BQ24193_STATUS_PG_MASK (1 << 2) +#define BQ24193_STATUS_DPM_MASK (1 << 3) +#define BQ24193_STATUS_CHRG_MASK (3 << 4) +#define BQ24193_STATUS_VBUS_MASK (3 << 6) + +// REG 9 masks. +#define BQ24193_FAULT_THERM_MASK (7 << 0) +#define BQ24193_FAULT_BATT_OVP_MASK (1 << 3) +#define BQ24193_FAULT_CHARGE_MASK (3 << 4) +#define BQ24193_FAULT_BOOST_MASK (1 << 6) +#define BQ24193_FAULT_WATCHDOG_MASK (1 << 7) + +// REG A masks. +#define BQ24193_VENDORPART_DEV_MASK (3 << 0) +#define BQ24193_VENDORPART_PN_MASK (7 << 3) + +enum BQ24193_reg { + BQ24193_InputSource = 0x00, + BQ24193_PORConfig = 0x01, + BQ24193_ChrgCurr = 0x02, + BQ24193_PreChrgTerm = 0x03, + BQ24193_ChrgVolt = 0x04, + BQ24193_ChrgTermTimer = 0x05, + BQ24193_IRCompThermal = 0x06, + BQ24193_Misc = 0x07, + BQ24193_Status = 0x08, + BQ24193_FaultReg = 0x09, + BQ24193_VendorPart = 0x0A, +}; + +enum BQ24193_reg_prop { + BQ24193_InputVoltageLimit, // REG 0. + BQ24193_InputCurrentLimit, // REG 0. + BQ24193_SystemMinimumVoltage, // REG 1. + BQ24193_FastChargeCurrentLimit, // REG 2. + BQ24193_ChargeVoltageLimit, // REG 4. + BQ24193_RechargeThreshold, // REG 4. + BQ24193_ThermalRegulation, // REG 6. + BQ24193_ChargeStatus, // REG 8. + BQ24193_TempStatus, // REG 9. + BQ24193_DevID, // REG A. + BQ24193_ProductNumber, // REG A. +}; + +#endif /* MAX77XXX_H */ diff --git a/Source/sys-clk/sysmodule/src/notification.h b/Source/sys-clk/sysmodule/src/notification.h new file mode 100644 index 00000000..4000df1a --- /dev/null +++ b/Source/sys-clk/sysmodule/src/notification.h @@ -0,0 +1,31 @@ +#pragma once + +#include +#include +#include + +static void writeNotification(const std::string& message) { + const char* flagPath = "sdmc:/config/ultrahand/flags/NOTIFICATIONS.flag"; + + // Check if flag file exists + FILE* flagFile = fopen(flagPath, "r"); + if (!flagFile) { + // Flag file does not exist, do nothing + return; + } + fclose(flagFile); + + // Generate filename with timestamp + std::string filename = "Horzon OC -" + std::to_string(std::time(nullptr)) + ".notify"; + std::string fullPath = "sdmc:/config/ultrahand/notifications/" + filename; + + // Write JSON manually + FILE* file = fopen(fullPath.c_str(), "w"); + if (file) { + fprintf(file, "{\n"); + fprintf(file, " \"text\": \"%s\",\n", message.c_str()); + fprintf(file, " \"fontSize\": 28\n"); + fprintf(file, "}\n"); + fclose(file); + } + } diff --git a/Source/sys-clk/sysmodule/src/process_management.cpp b/Source/sys-clk/sysmodule/src/process_management.cpp index 8cb369cc..aacd9367 100644 --- a/Source/sys-clk/sysmodule/src/process_management.cpp +++ b/Source/sys-clk/sysmodule/src/process_management.cpp @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #include "process_management.h" #include "file_utils.h" #include "errors.h" diff --git a/Source/sys-clk/sysmodule/src/process_management.h b/Source/sys-clk/sysmodule/src/process_management.h index 0727c276..aa972846 100644 --- a/Source/sys-clk/sysmodule/src/process_management.h +++ b/Source/sys-clk/sysmodule/src/process_management.h @@ -1,5 +1,21 @@ /* - * -------------------------------------------------------------------------- + * Copyright (c) Souldbminer and Horizon OC Contributors + * + * 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 . + * + */ + +/* -------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * , , * wrote this file. As long as you retain this notice you can do whatever you @@ -8,6 +24,7 @@ * -------------------------------------------------------------------------- */ + #pragma once #include #include diff --git a/Source/sys-clk/sysmodule/src/soctherm.h b/Source/sys-clk/sysmodule/src/soctherm.h new file mode 100644 index 00000000..24a2c755 --- /dev/null +++ b/Source/sys-clk/sysmodule/src/soctherm.h @@ -0,0 +1,131 @@ +/* * HOS soctherm driver by Souldbminer & Dominatorul * Licensed under the LGPLv3 */ +#ifndef _SOCTHERM_H_ +#define _SOCTHERM_H_ + +#include + +#define SOCTHERM_BASE 0x700E2000ULL + +#define SENSOR_TEMP1 0x1c8 +#define SENSOR_TEMP2 0x1cc + +#define SOC_THERM_THERMCTL_LEVEL0_GROUP_CPU_0 0x0 +#define SOC_THERM_THERMCTL_LEVEL0_GROUP_GPU_0 0x4 +#define SOC_THERM_THERMCTL_LEVEL0_GROUP_MEM_0 0x8 +#define SOC_THERM_THERMCTL_LEVEL0_GROUP_TSENSE_0 0xC + +#define SENSOR_CPU0_CONFIG0 0xC0 +#define SENSOR_CPU1_CONFIG0 0xE0 +#define SENSOR_CPU2_CONFIG0 0x100 +#define SENSOR_CPU3_CONFIG0 0x120 +#define SENSOR_GPU_CONFIG0 0x180 +#define SENSOR_PLLX_CONFIG0 0x1A0 + +#define SENSOR_CPU0_CONFIG1 0xC4 +#define SENSOR_CPU1_CONFIG1 0xE4 +#define SENSOR_CPU2_CONFIG1 0x104 +#define SENSOR_CPU3_CONFIG1 0x124 +#define SENSOR_GPU_CONFIG1 0x184 +#define SENSOR_PLLX_CONFIG1 0x1A4 + +#define SENSOR_CPU0_STATUS 0xC8 +#define SENSOR_GPU_STATUS 0x188 +#define SENSOR_PLLX_STATUS 0x1A8 + +#define SENSOR_CONFIG0_STOP_MASK (1U << 0) +#define SENSOR_CONFIG0_TALL_SHIFT 8 +#define SENSOR_CONFIG0_TALL_MASK (0xFFFFF << 8) + +#define SENSOR_CONFIG1_TEMP_ENABLE_MASK (1U << 31) +#define SENSOR_CONFIG1_TEN_COUNT_SHIFT 24 +#define SENSOR_CONFIG1_TEN_COUNT_MASK (0x3F << 24) +#define SENSOR_CONFIG1_TIDDQ_EN_SHIFT 15 +#define SENSOR_CONFIG1_TIDDQ_EN_MASK (0x3F << 15) +#define SENSOR_CONFIG1_TSAMPLE_SHIFT 0 +#define SENSOR_CONFIG1_TSAMPLE_MASK 0x3FF + +#define SENSOR_STATUS_VALID_MASK (1U << 31) + +#define TSENSOR_TALL_DEFAULT 16300 +#define TSENSOR_TIDDQ_EN_DEFAULT 1 +#define TSENSOR_TEN_COUNT_DEFAULT 1 +#define TSENSOR_TSAMPLE_DEFAULT 120 + +#define SENSOR_TEMP1_CPU_TEMP_MASK (0xFFFF << 16) +#define SENSOR_TEMP1_GPU_TEMP_MASK 0xFFFF +#define SENSOR_TEMP2_PLLX_TEMP_MASK 0xFFFF + +#define READBACK_VALUE_MASK 0xFF00 +#define READBACK_VALUE_SHIFT 8 +#define READBACK_ADD_HALF (1 << 7) +#define READBACK_NEGATE (1 << 0) + +#define REG_GET_MASK(r, m) (((r) & (m)) >> (__builtin_ffs(m) - 1)) + +// Timing constants (in microseconds) +#define SENSOR_STABILIZATION_DELAY_US 2000 // 2ms for sensor to stabilize +#define SENSOR_READ_DELAY_US 100 // 100us between config operations + +// Makes my life easier +#define BITMASK(bits) (0UL | (bits)) +#define BIT(n) (1UL << (n)) + +#define WRITE_REG_BIT(addr, bit, val) do { \ + u32 _tmp; \ + svcReadWriteRegister(&_tmp, (addr), 0, false); \ + if (val) \ + _tmp |= (1U << (bit)); /* set bit */ \ + else \ + _tmp &= ~(1U << (bit)); /* clear bit */ \ + svcReadWriteRegister(&_tmp, (addr), 0, true); \ +} while (0) + +typedef enum { + SENSOR_CPU = 0, + SENSOR_GPU = 1, + SENSOR_PLLX = 2, +} SocthermSensor; + +void socthermInit(void) { + WRITE_REG_BIT(SOCTHERM_BASE + SENSOR_CPU0_CONFIG0, 0, 0); // start cpu0 + WRITE_REG_BIT(SOCTHERM_BASE + SENSOR_CPU0_CONFIG1, 31, 1); // start cpu0 + + WRITE_REG_BIT(SOCTHERM_BASE + SENSOR_CPU1_CONFIG0, 0, 0); // start cpu1 + WRITE_REG_BIT(SOCTHERM_BASE + SENSOR_CPU1_CONFIG1, 31, 1); // start cpu1 + + WRITE_REG_BIT(SOCTHERM_BASE + SENSOR_CPU2_CONFIG0, 0, 0); // start cpu2 + WRITE_REG_BIT(SOCTHERM_BASE + SENSOR_CPU2_CONFIG1, 31, 1); // start cpu2 + + WRITE_REG_BIT(SOCTHERM_BASE + SENSOR_CPU3_CONFIG0, 0, 0); // start cpu3 + WRITE_REG_BIT(SOCTHERM_BASE + SENSOR_CPU3_CONFIG1, 31, 1); // start cpu3 + + WRITE_REG_BIT(SOCTHERM_BASE + SENSOR_GPU_CONFIG0, 0, 0); // start gpu + WRITE_REG_BIT(SOCTHERM_BASE + SENSOR_GPU_CONFIG1, 31, 1); // start gpu + + WRITE_REG_BIT(SOCTHERM_BASE + SENSOR_PLLX_CONFIG0, 0, 0); // start pllx + WRITE_REG_BIT(SOCTHERM_BASE + SENSOR_PLLX_CONFIG1, 31, 1); // start pllx +} + +int socthermRead(SocthermSensor sensor) { + switch(sensor) { + case SENSOR_CPU: { + u32 temp_reg; + svcReadWriteRegister(&temp_reg, SOCTHERM_BASE + SENSOR_TEMP1, 0, false); + return REG_GET_MASK(temp_reg, SENSOR_TEMP1_CPU_TEMP_MASK); + } + case SENSOR_GPU: { + u32 temp_reg; + svcReadWriteRegister(&temp_reg, SOCTHERM_BASE + SENSOR_TEMP1, 0, false); + return REG_GET_MASK(temp_reg, SENSOR_TEMP1_GPU_TEMP_MASK); + } + case SENSOR_PLLX: { + u32 temp_reg; + svcReadWriteRegister(&temp_reg, SOCTHERM_BASE + SENSOR_TEMP2, 0, false); + return REG_GET_MASK(temp_reg, SENSOR_TEMP2_PLLX_TEMP_MASK); + } + default: + return -1; // Invalid sensor + } +} + +#endif // _SOCTHERM_H_ \ No newline at end of file diff --git a/Source/sys-clk/sysmodule/toolbox.json b/Source/sys-clk/sysmodule/toolbox.json index 83ac964c..4874c6c7 100644 --- a/Source/sys-clk/sysmodule/toolbox.json +++ b/Source/sys-clk/sysmodule/toolbox.json @@ -1,5 +1,5 @@ { - "name" : "hoc-clk", + "name" : "Horizon OC", "tid" : "00FF0000636C6BFF", "requires_reboot": false } \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/backup.ini b/Ultrahand/OC Toolkit/backup.ini deleted file mode 100644 index f3693a4e..00000000 --- a/Ultrahand/OC Toolkit/backup.ini +++ /dev/null @@ -1,496 +0,0 @@ -;creator='ppkantorski, B3711' - -[Backup System] -[*Slot 0] -;mode=slot - -[RAM Table 0] -;mode=table -;spacing=4 -;gap=25 - -ini_file '/atmosphere/kips/.bakTK/Slot 0.ini' -json_file './json/max_clocks.json' -'Timings' = {ini_file(Backup,Timings)} -json_file './json/dram.json' -'DRAM'= {json_file(0,{ini_file(Backup,DRAM)})} -mariko: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzM)})} -json_file './json/vddq.json' -'Vddq' = {json_file(0,{ini_file(Backup,ramVDDQ)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} -erista: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzE)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} - -[*Details?slot0] -;mode=forwarder -del '/atmosphere/kips/.bakTK/tmp.ini' -cp '/atmosphere/kips/.bakTK/Slot 0.ini' '/atmosphere/kips/.bakTK/tmp.ini' -package_source './backup_info.ini' - -[*Label?slot0] -;mode=option -list_file_source ./backup_labels.txt -set-footer {list_file_source(*)} - -[Backup?slot0] -;mode=slot -del /atmosphere/kips/.bakTK/tmp.ini -del '/atmosphere/kips/.bakTK/Slot 0.ini' -exec backup -mv '/atmosphere/kips/.bakTK/tmp.ini' '/atmosphere/kips/.bakTK/Slot 0.ini' -#set-ini-val './config.ini' 'Restore?slot0' footer '{timestamp("%Y-%m-%d %H:%M")}' -ini_file '/atmosphere/kips/.bakTK/Slot 0.ini' -json_file './json/max_clocks.json' -set-ini-val './config.ini' '*Slot 0' footer {json_file(0,{ini_file(Backup,ramMHzM)})} -set-footer '{timestamp("%Y-%m-%d %H:%M")}' -refresh-to 'Backup' '' false - - -[Restore?slot0] -;mode=slot -try: -delete '/atmosphere/kips/.bakTK/tmp.ini' -cp '/atmosphere/kips/.bakTK/Slot 0.ini' '/atmosphere/kips/.bakTK/tmp.ini' -exec restore -delete '/atmosphere/kips/.bakTK/tmp.ini' -exec boot -set-footer '{timestamp("%Y-%m-%d %H:%M")}' - - -[Delete Backup?slot0] -;mode=default -del '/atmosphere/kips/.bakTK/Slot 0.ini' -remove-ini-key './config.ini' '*Label?slot0' footer -remove-ini-key './config.ini' 'Backup?slot0' footer -remove-ini-key './config.ini' 'Restore?slot0' footer -remove-ini-section './config.ini' '*Slot 0' -refresh-to 'Delete Backup' '' false - - - -[*Slot 1] -;mode=slot - -[RAM Table 1] -;mode=table -;spacing=4 -;gap=25 - -ini_file '/atmosphere/kips/.bakTK/Slot 1.ini' -json_file './json/max_clocks.json' -'Timings' = {ini_file(Backup,Timings)} -json_file './json/dram.json' -'DRAM'= {json_file(0,{ini_file(Backup,DRAM)})} -mariko: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzM)})} -json_file './json/vddq.json' -'Vddq' = {json_file(0,{ini_file(Backup,ramVDDQ)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} -erista: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzE)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} - -[*Details?slot1] -;mode=forwarder -del '/atmosphere/kips/.bakTK/tmp.ini' -cp '/atmosphere/kips/.bakTK/Slot 1.ini' '/atmosphere/kips/.bakTK/tmp.ini' -package_source './backup_info.ini' - -[*Label?slot1] -;mode=option -list_file_source ./backup_labels.txt -set-footer {list_file_source(*)} - - -[Backup?slot1] -;mode=slot -del /atmosphere/kips/.bakTK/tmp.ini -del '/atmosphere/kips/.bakTK/Slot 1.ini' -exec backup -mv '/atmosphere/kips/.bakTK/tmp.ini' '/atmosphere/kips/.bakTK/Slot 1.ini' -#set-ini-val './config.ini' 'Restore?slot1' footer '{timestamp("%Y-%m-%d %H:%M")}' -ini_file '/atmosphere/kips/.bakTK/Slot 1.ini' -json_file './json/max_clocks.json' -set-ini-val './config.ini' '*Slot 1' footer {json_file(0,{ini_file(Backup,ramMHzM)})} -set-footer '{timestamp("%Y-%m-%d %H:%M")}' -refresh-to 'Backup' '' false - -[Restore?slot1] -;mode=slot -try: -delete '/atmosphere/kips/.bakTK/tmp.ini' -cp '/atmosphere/kips/.bakTK/Slot 1.ini' '/atmosphere/kips/.bakTK/tmp.ini' -exec restore -delete '/atmosphere/kips/.bakTK/tmp.ini' -exec boot -set-footer '{timestamp("%Y-%m-%d %H:%M")}' - - -[Delete Backup?slot1] -;mode=default -del '/atmosphere/kips/.bakTK/Slot 1.ini' -remove-ini-key './config.ini' '*Label?slot1' footer -remove-ini-key './config.ini' 'Backup?slot1' footer -remove-ini-key './config.ini' 'Restore?slot1' footer -remove-ini-section './config.ini' '*Slot 1' -refresh-to 'Delete Backup' '' false - -[*Slot 2] -;mode=slot - -[RAM Table 2] -;mode=table -;spacing=4 -;gap=25 - -ini_file '/atmosphere/kips/.bakTK/Slot 2.ini' -json_file './json/max_clocks.json' -'Timings' = {ini_file(Backup,Timings)} -json_file './json/dram.json' -'DRAM'= {json_file(0,{ini_file(Backup,DRAM)})} -mariko: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzM)})} -json_file './json/vddq.json' -'Vddq' = {json_file(0,{ini_file(Backup,ramVDDQ)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} -erista: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzE)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} - -[*Details?slot2] -;mode=forwarder -del '/atmosphere/kips/.bakTK/tmp.ini' -cp '/atmosphere/kips/.bakTK/Slot 2.ini' '/atmosphere/kips/.bakTK/tmp.ini' -package_source './backup_info.ini' - -[*Label?slot2] -;mode=option -list_file_source ./backup_labels.txt -set-footer {list_file_source(*)} - - -[Backup?slot2] -;mode=slot -del /atmosphere/kips/.bakTK/tmp.ini -del '/atmosphere/kips/.bakTK/Slot 2.ini' -exec backup -mv '/atmosphere/kips/.bakTK/tmp.ini' '/atmosphere/kips/.bakTK/Slot 2.ini' -#set-ini-val './config.ini' 'Restore?slot2' footer '{timestamp("%Y-%m-%d %H:%M")}' -ini_file '/atmosphere/kips/.bakTK/Slot 2.ini' -json_file './json/max_clocks.json' -set-ini-val './config.ini' '*Slot 2' footer {json_file(0,{ini_file(Backup,ramMHzM)})} -set-footer '{timestamp("%Y-%m-%d %H:%M")}' -refresh-to 'Backup' '' false - -[Restore?slot2] -;mode=slot -try: -delete '/atmosphere/kips/.bakTK/tmp.ini' -cp '/atmosphere/kips/.bakTK/Slot 2.ini' '/atmosphere/kips/.bakTK/tmp.ini' -exec restore -delete '/atmosphere/kips/.bakTK/tmp.ini' -exec boot -set-footer '{timestamp("%Y-%m-%d %H:%M")}' - -[Delete Backup?slot2] -;mode=default -del '/atmosphere/kips/.bakTK/Slot 2.ini' -remove-ini-key './config.ini' '*Label?slot2' footer -remove-ini-key './config.ini' 'Backup?slot2' footer -remove-ini-key './config.ini' 'Restore?slot2' footer -remove-ini-section './config.ini' '*Slot 2' -refresh-to 'Delete Backup' '' false - - -[*Slot 3] -;mode=slot - -[RAM Table 3] -;mode=table -;spacing=4 -;gap=25 - -ini_file '/atmosphere/kips/.bakTK/Slot 3.ini' -json_file './json/max_clocks.json' -'Timings' = {ini_file(Backup,Timings)} -json_file './json/dram.json' -'DRAM'= {json_file(0,{ini_file(Backup,DRAM)})} -mariko: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzM)})} -json_file './json/vddq.json' -'Vddq' = {json_file(0,{ini_file(Backup,ramVDDQ)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} -erista: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzE)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} - -[*Details?slot3] -;mode=forwarder -del '/atmosphere/kips/.bakTK/tmp.ini' -cp '/atmosphere/kips/.bakTK/Slot 3.ini' '/atmosphere/kips/.bakTK/tmp.ini' -package_source './backup_info.ini' - -[*Label?slot3] -;mode=option -list_file_source ./backup_labels.txt -set-footer {list_file_source(*)} - -[Backup?slot3] -;mode=slot -del /atmosphere/kips/.bakTK/tmp.ini -del '/atmosphere/kips/.bakTK/Slot 3.ini' -exec backup -mv '/atmosphere/kips/.bakTK/tmp.ini' '/atmosphere/kips/.bakTK/Slot 3.ini' -#set-ini-val './config.ini' 'Restore?slot3' footer '{timestamp("%Y-%m-%d %H:%M")}' -ini_file '/atmosphere/kips/.bakTK/Slot 3.ini' -json_file './json/max_clocks.json' -set-ini-val './config.ini' '*Slot 3' footer {json_file(0,{ini_file(Backup,ramMHzM)})} -set-footer '{timestamp("%Y-%m-%d %H:%M")}' -refresh-to 'Backup' '' false - -[Restore?slot3] -;mode=slot -try: -delete '/atmosphere/kips/.bakTK/tmp.ini' -cp '/atmosphere/kips/.bakTK/Slot 3.ini' '/atmosphere/kips/.bakTK/tmp.ini' -exec restore -delete '/atmosphere/kips/.bakTK/tmp.ini' -exec boot -set-footer '{timestamp("%Y-%m-%d %H:%M")}' - -[Delete Backup?slot3] -;mode=default -del '/atmosphere/kips/.bakTK/Slot 3.ini' -remove-ini-key './config.ini' '*Label?slot3' footer -remove-ini-key './config.ini' 'Backup?slot3' footer -remove-ini-key './config.ini' 'Restore?slot3' footer -remove-ini-section './config.ini' '*Slot 3' -refresh-to 'Delete Backup' '' false - - -[*Slot 4] -;mode=slot - -[RAM Table 4] -;mode=table -;spacing=4 -;gap=25 - -ini_file '/atmosphere/kips/.bakTK/Slot 4.ini' -json_file './json/max_clocks.json' -'Timings' = {ini_file(Backup,Timings)} -json_file './json/dram.json' -'DRAM'= {json_file(0,{ini_file(Backup,DRAM)})} -mariko: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzM)})} -json_file './json/vddq.json' -'Vddq' = {json_file(0,{ini_file(Backup,ramVDDQ)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} -erista: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzE)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} - -[*Details?slot4] -;mode=forwarder -del '/atmosphere/kips/.bakTK/tmp.ini' -cp '/atmosphere/kips/.bakTK/Slot 4.ini' '/atmosphere/kips/.bakTK/tmp.ini' -package_source './backup_info.ini' - -[*Label?slot4] -;mode=option -list_file_source ./backup_labels.txt -set-footer {list_file_source(*)} - -[Backup?slot4] -;mode=slot -del /atmosphere/kips/.bakTK/tmp.ini -del '/atmosphere/kips/.bakTK/Slot 4.ini' -exec backup -mv '/atmosphere/kips/.bakTK/tmp.ini' '/atmosphere/kips/.bakTK/Slot 4.ini' -#set-ini-val './config.ini' 'Restore?slot4' footer '{timestamp("%Y-%m-%d %H:%M")}' -ini_file '/atmosphere/kips/.bakTK/Slot 4.ini' -json_file './json/max_clocks.json' -set-ini-val './config.ini' '*Slot 4' footer {json_file(0,{ini_file(Backup,ramMHzM)})} -set-footer '{timestamp("%Y-%m-%d %H:%M")}' -refresh-to 'Backup' '' false - -[Restore?slot4] -;mode=slot -try: -delete '/atmosphere/kips/.bakTK/tmp.ini' -cp '/atmosphere/kips/.bakTK/Slot 4.ini' '/atmosphere/kips/.bakTK/tmp.ini' -exec restore -delete '/atmosphere/kips/.bakTK/tmp.ini' -exec boot -set-footer '{timestamp("%Y-%m-%d %H:%M")}' - -[Delete Backup?slot4] -;mode=default -del '/atmosphere/kips/.bakTK/Slot 4.ini' -remove-ini-key './config.ini' '*Label?slot4' footer -remove-ini-key './config.ini' 'Backup?slot4' footer -remove-ini-key './config.ini' 'Restore?slot4' footer -remove-ini-section './config.ini' '*Slot 4' -refresh-to 'Delete Backup' '' false - -[*Slot 5] -;mode=slot - -[RAM Table 5] -;mode=table -;spacing=4 -;gap=25 - -ini_file '/atmosphere/kips/.bakTK/Slot 5.ini' -json_file './json/max_clocks.json' -'Timings' = {ini_file(Backup,Timings)} -json_file './json/dram.json' -'DRAM'= {json_file(0,{ini_file(Backup,DRAM)})} -mariko: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzM)})} -json_file './json/vddq.json' -'Vddq' = {json_file(0,{ini_file(Backup,ramVDDQ)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} -erista: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzE)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} - -[*Details?slot5] -;mode=forwarder -del '/atmosphere/kips/.bakTK/tmp.ini' -cp '/atmosphere/kips/.bakTK/Slot 5.ini' '/atmosphere/kips/.bakTK/tmp.ini' -package_source './backup_info.ini' - -[*Label?slot5] -;mode=option -list_file_source ./backup_labels.txt -set-footer {list_file_source(*)} - - -[Backup?slot5] -;mode=slot -del /atmosphere/kips/.bakTK/tmp.ini -del '/atmosphere/kips/.bakTK/Slot 5.ini' -exec backup -mv '/atmosphere/kips/.bakTK/tmp.ini' '/atmosphere/kips/.bakTK/Slot 5.ini' -#set-ini-val './config.ini' 'Restore?slot5' footer '{timestamp("%Y-%m-%d %H:%M")}' -ini_file '/atmosphere/kips/.bakTK/Slot 5.ini' -json_file './json/max_clocks.json' -set-ini-val './config.ini' '*Slot 5' footer {json_file(0,{ini_file(Backup,ramMHzM)})} -set-footer '{timestamp("%Y-%m-%d %H:%M")}' -refresh-to 'Backup' '' false - -[Restore?slot5] -;mode=slot -try: -delete '/atmosphere/kips/.bakTK/tmp.ini' -cp '/atmosphere/kips/.bakTK/Slot 5.ini' '/atmosphere/kips/.bakTK/tmp.ini' -exec restore -delete '/atmosphere/kips/.bakTK/tmp.ini' -exec boot -set-footer '{timestamp("%Y-%m-%d %H:%M")}' - -[Delete Backup?slot5] -;mode=default -del '/atmosphere/kips/.bakTK/Slot 5.ini' -remove-ini-key './config.ini' '*Label?slot5' footer -remove-ini-key './config.ini' 'Backup?slot5' footer -remove-ini-key './config.ini' 'Restore?slot5' footer -remove-ini-section './config.ini' '*Slot 5' -refresh-to 'Delete Backup' '' false - -[*Slot 6] -;mode=slot - -[RAM Table 6] -;mode=table -;spacing=4 -;gap=25 - -ini_file '/atmosphere/kips/.bakTK/Slot 6.ini' -json_file './json/max_clocks.json' -'Timings' = {ini_file(Backup,Timings)} -json_file './json/dram.json' -'DRAM'= {json_file(0,{ini_file(Backup,DRAM)})} -mariko: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzM)})} -json_file './json/vddq.json' -'Vddq' = {json_file(0,{ini_file(Backup,ramVDDQ)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} -erista: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzE)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} - -[*Details?slot6] -;mode=forwarder -del '/atmosphere/kips/.bakTK/tmp.ini' -cp '/atmosphere/kips/.bakTK/Slot 6.ini' '/atmosphere/kips/.bakTK/tmp.ini' -package_source './backup_info.ini' - -[*Label?slot6] -;mode=option -list_file_source ./backup_labels.txt -set-footer {list_file_source(*)} - -[Backup?slot6] -;mode=slot -del /atmosphere/kips/.bakTK/tmp.ini -del '/atmosphere/kips/.bakTK/Slot 6.ini' -exec backup -mv '/atmosphere/kips/.bakTK/tmp.ini' '/atmosphere/kips/.bakTK/Slot 6.ini' -#set-ini-val './config.ini' 'Restore?slot6' footer '{timestamp("%Y-%m-%d %H:%M")}' -ini_file '/atmosphere/kips/.bakTK/Slot 6.ini' -json_file './json/max_clocks.json' -set-ini-val './config.ini' '*Slot 6' footer {json_file(0,{ini_file(Backup,ramMHzM)})} -set-footer '{timestamp("%Y-%m-%d %H:%M")}' -refresh-to 'Backup' '' false - -[Restore?slot6] -;mode=slot -try: -delete '/atmosphere/kips/.bakTK/tmp.ini' -cp '/atmosphere/kips/.bakTK/Slot 6.ini' '/atmosphere/kips/.bakTK/tmp.ini' -exec restore -delete '/atmosphere/kips/.bakTK/tmp.ini' -exec boot -set-footer '{timestamp("%Y-%m-%d %H:%M")}' - -[Delete Backup?slot6] -;mode=default -del '/atmosphere/kips/.bakTK/Slot 6.ini' -remove-ini-key './config.ini' '*Label?slot6' footer -remove-ini-key './config.ini' 'Backup?slot6' footer -remove-ini-key './config.ini' 'Restore?slot6' footer -remove-ini-section './config.ini' '*Slot 6' -refresh-to 'Delete Backup' '' false - diff --git a/Ultrahand/OC Toolkit/backup_info.ini b/Ultrahand/OC Toolkit/backup_info.ini deleted file mode 100644 index 18870af4..00000000 --- a/Ultrahand/OC Toolkit/backup_info.ini +++ /dev/null @@ -1,112 +0,0 @@ -;creator=ppkantorski, MestreYodaRossi, B3711 - - -[@Presets] -[RAM] -[RAM Table] -;mode=table -;spacing=4 -;gap=0 -ini_file '/atmosphere/kips/.bakTK/tmp.ini' -'Timings' = {ini_file(Backup,Timings)} -ini_file '/atmosphere/kips/.bakTK/tmp.ini' -json_file './json/dram.json' -'DRAM'= {json_file(0,{ini_file(Backup,DRAM)})} -mariko: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzM)})} -json_file './json/vddq.json' -'Vddq' = {json_file(0,{ini_file(Backup,ramVDDQ)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} -json_file './json/ram_dvb.json' -'EMC DVB' = {json_file(0,{ini_file(Backup,DVB)})} -erista: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzE)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} -json_file './json/ram_dvb.json' -'EMC DVB' = {json_file(0,{ini_file(Backup,DVB)})} - - -[CPU] -[CPU Table] -;mode=table -;spacing=4 -;gap=4 -ini_file '/atmosphere/kips/.bakTK/tmp.ini' -json_file './json/numbers.json' -'UV Level' = {json_file(0,{ini_file(Backup,cpuUVL)})} -mariko: -json_file './json/high_freq_uv.json' -'High Freq UV Level' = {json_file(0,{ini_file(Backup,cpuUVH)})} -json_file './json/cpu_table.json' -'Table Config' = {json_file(0,{ini_file(Backup,CPUTABLE)})} -json_file './json/mv.json' -'Low Freq Vmin' = {json_file(0,{ini_file(Backup,cpuVminL)})} -'High Freq Vmin' = {json_file(0,{ini_file(Backup,cpuVminH)})} -json_file './json/voltage_limit.json' -'Volt Limit' = {json_file(0,{ini_file(Backup,cpuVmaxM)})} -json_file './json/max_clocks.json' -'Boost Clock' = {json_file(0,{ini_file(Backup,cpuBoost)})} -json_file './json/cpu_max_clock_m.json' -'Max Clock' = {json_file(0,{ini_file(Backup,CPUUL)})} -erista: -json_file './json/mv.json' -'Vmin' = {json_file(0,{ini_file(Backup,cpuVminE)})} -json_file './json/voltage_limit.json' -'Volt Limit' = {json_file(0,{ini_file(Backup,cpuVmaxE)})} -json_file './json/max_clocks.json' -'Boost Clock' = {json_file(0,{ini_file(Backup,cpuBoost)})} - -[GPU] -[GPU Table] -;mode=table -;spacing=4 -;gap=0 -ini_file '/atmosphere/kips/.bakTK/tmp.ini' -mariko: -json_file './json/gpu_uv_m.json' -'UV Level' = {json_file(0,{ini_file(Backup,gpuUVM)})} -json_file './json/gpu_dvfs_offset_info.json' -'DVFS' = {json_file(0,{ini_file(Backup,gpuDvfsO)})} -json_file './json/vmin.json' -'Vmin' = {json_file(0,{ini_file(Backup,gpuVminM)})} -'Vmax' = {json_file(0,{ini_file(Backup,gpuVmax)})} -json_file './json/voltage_offset.json' -'Volt Offset' = {json_file(0,{ini_file(Backup,gpuOFF)})} -erista: -json_file './json/gpu_uv_e.json' -'UV Level' = {json_file(0,{ini_file(Backup,gpuUVE)})} -json_file './json/mv.json' -'Vmin' = {json_file(0,{ini_file(Backup,gpuVminE)})} -json_file './json/voltage_offset.json' -'Volt Offset' = {json_file(0,{ini_file(Backup,gpuOFF)})} -;gap=100 - -[@Custom Table] -[Custom Table] -[Custom Table] -;mode=table -;spacing=8 -;gap=0 -ini_file '/atmosphere/kips/.bakTK/tmp.ini' -json_file './json/vmin.json' -'76 - 230 MHz' = {json_file(0,{ini_file(Backup,230UV3)})} -'307 MHz' = {json_file(0,{ini_file(Backup,307UV3)})} -'384 MHz' = {json_file(0,{ini_file(Backup,384UV3)})} -'460 MHz' = {json_file(0,{ini_file(Backup,460UV3)})} -'537 MHz' = {json_file(0,{ini_file(Backup,537UV3)})} -'614 MHz' = {json_file(0,{ini_file(Backup,614UV3)})} -'691 MHz' = {json_file(0,{ini_file(Backup,691UV3)})} -'768 MHz' = {json_file(0,{ini_file(Backup,768UV3)})} -'844 MHz' = {json_file(0,{ini_file(Backup,844UV3)})} -'921 MHz' = {json_file(0,{ini_file(Backup,921UV3)})} -'998 MHz' = {json_file(0,{ini_file(Backup,998UV3)})} -mariko: -'1075 MHz' = {json_file(0,{ini_file(Backup,1075UV3)})} -'1152 MHz' = {json_file(0,{ini_file(Backup,1152UV3)})} -'1228 MHz' = {json_file(0,{ini_file(Backup,1228UV3)})} -'1267 MHz' = {json_file(0,{ini_file(Backup,1267UV3)})} -'1305 MHz' = {json_file(0,{ini_file(Backup,1305UV3)})} diff --git a/Ultrahand/OC Toolkit/backup_labels.txt b/Ultrahand/OC Toolkit/backup_labels.txt deleted file mode 100644 index b668045a..00000000 --- a/Ultrahand/OC Toolkit/backup_labels.txt +++ /dev/null @@ -1,6 +0,0 @@ -⋯ -docked -handheld -retro -stable -test diff --git a/Ultrahand/OC Toolkit/boot_package.ini b/Ultrahand/OC Toolkit/boot_package.ini deleted file mode 100644 index babaa87a..00000000 --- a/Ultrahand/OC Toolkit/boot_package.ini +++ /dev/null @@ -1,357 +0,0 @@ -[boot] -clear hex_sum_cache -hex_file '/atmosphere/kips/loader.kip' - -json_file './json/dram.json' -set-ini-val './config.ini' '*DRAM' footer {json_file(0,{hex_file(CUST,64,1)})} - -json_file './json/vdd2.json' -set-ini-val './config.ini' '*Vdd2' footer {json_file(0,{hex_file(CUST,68,3)})} - -json_file './json/max_clocks.json' -set-ini-val './config.ini' '*Boost Clock?CPU' footer {json_file(0,{hex_file(CUST,8,3)})} - -json_file './json/numbers.json' -set-ini-val './config.ini' 'Undervolt Mode?CPU' index {json_file(0,{hex_file(CUST,12,1)})} - -json_file './json/voltage_offset_index.json' -set-ini-val './config.ini' 'Voltage Offset' index {json_file(0,{hex_file(CUST,44,1)})} - - -exec cUpdateTimings - -mariko: -exec cMariko_boot - -erista: -exec cErista_boot - - -[cUpdateTimings] -hex_file '/atmosphere/kips/loader.kip' -json_file './json/numbers.json' -set-ini-val './config.ini' '*Timings' footer '({json_file(0,{hex_file(CUST,88,1)})}-{json_file(0,{hex_file(CUST,92,1)})}-{json_file(0,{hex_file(CUST,96,1)})}) {json_file(0,{hex_file(CUST,100,1)})}-{json_file(0,{hex_file(CUST,104,1)})}-{json_file(0,{hex_file(CUST,108,1)})}-{json_file(0,{hex_file(CUST,112,1)})}-{json_file(0,{hex_file(CUST,116,1)})}' - - - -[cTimings] -hex_file '/atmosphere/kips/loader.kip' -json_file './json/numbers.json' -set-ini-val './config.ini' 'T1 tRCD' index {json_file(0,{hex_file(CUST,88,1)})} -set-ini-val './config.ini' 'T2 tRP' index {json_file(0,{hex_file(CUST,92,1)})} -set-ini-val './config.ini' 'T3 tRAS' index {json_file(0,{hex_file(CUST,96,1)})} -set-ini-val './config.ini' 'T4 tRRD' index {json_file(0,{hex_file(CUST,100,1)})} -set-ini-val './config.ini' 'T5 tRFC' index {json_file(0,{hex_file(CUST,104,1)})} -set-ini-val './config.ini' 'T6 tRTW' index {json_file(0,{hex_file(CUST,108,1)})} -set-ini-val './config.ini' 'T7 tWTR' index {json_file(0,{hex_file(CUST,112,1)})} -set-ini-val './config.ini' 'T8 tREFI' index {json_file(0,{hex_file(CUST,116,1)})} - - - -[cCutomTable] -hex_file '/atmosphere/kips/loader.kip' -json_file './json/vmin.json' -set-ini-val './config.ini' '*76 - 230 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,132,2)})} -set-ini-val './config.ini' '*307 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,136,2)})} -set-ini-val './config.ini' '*384 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,140,2)})} -set-ini-val './config.ini' '*460 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,144,2)})} -set-ini-val './config.ini' '*537 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,148,2)})} -set-ini-val './config.ini' '*614 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,152,2)})} -set-ini-val './config.ini' '*691 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,156,2)})} -set-ini-val './config.ini' '*768 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,160,2)})} -set-ini-val './config.ini' '*844 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,164,2)})} -set-ini-val './config.ini' '*921 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,168,2)})} -set-ini-val './config.ini' '*998 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,172,2)})} -set-ini-val './config.ini' '*1075 MHz?GPUUV3erista' footer {json_file(0,{hex_file(CUST,176,2)})} -set-ini-val './config.ini' '*1152 MHz?GPUUV3erista' footer {json_file(0,{hex_file(CUST,180,2)})} - -mariko: -set-ini-val './config.ini' '*1075 MHz?GPUUV3mariko' footer {json_file(0,{hex_file(CUST,176,2)})} -set-ini-val './config.ini' '*1152 MHz?GPUUV3mariko' footer {json_file(0,{hex_file(CUST,180,2)})} -set-ini-val './config.ini' '*1228 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,184,2)})} -set-ini-val './config.ini' '*1267 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,188,2)})} -set-ini-val './config.ini' '*1305 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,192,2)})} -set-ini-val './config.ini' '*1344 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,196,2)})} -set-ini-val './config.ini' '*1382 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,200,2)})} -set-ini-val './config.ini' '*1420 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,204,2)})} -set-ini-val './config.ini' '*1459 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,208,2)})} -set-ini-val './config.ini' '*1497 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,212,2)})} -set-ini-val './config.ini' '*1536 MHz?GPUUV3' footer {json_file(0,{hex_file(CUST,216,2)})} - - -[cSystemSettings] -hex_file '/atmosphere/kips/loader.kip' - -ini_file '/config/status-monitor/config.ini' -json_file './json/keys_b.json' -set-ini-val './config.ini' '*Status Monitor' footer {json_file(0,{ini_file(status-monitor,key_combo)})} - -ini_file '/atmosphere/config/override_config.ini' -json '[{"null":"Off", "R":"On", "!R":"Off"}]' -set-ini-val './config.ini' 'Hold R for Homebrew' footer {json(0,{ini_file(hbl_config,override_key)})} - - -ini_file '/atmosphere/config/system_settings.ini' -json '[{"null":"On", "u8!0x1":"On", "u8!0x0":"Off"}]' -set-ini-val './config.ini' 'GPU Scheduling' footer {json(0,{ini_file(am.gpu,gpu_scheduling_enabled)})} - -ini_file '/atmosphere/config/system_settings.ini' -json '[{"null":"Off", "u8!0x1":"On", "u8!0x0":"Off"}]' -set-ini-val './config.ini' 'Controller Sync' footer {json(0,{ini_file(atmosphere,enable_external_bluetooth_db)})} - - -mariko: -json '[{"01":"Off", "00":"On"}]' -set-ini-val './config.ini' '1305 MHz+ GPU' footer {json(0,{hex_file(CUST,256,1)})} -json_file './json/cpu_max_freq_index.json' -set-ini-val './config.ini' 'Max CPU Freq?mariko' index {json_file(0,{hex_file(CUST,264,1)})} - -erista: -json '[{"01":"Off", "00":"On"}]' -set-ini-val './config.ini' '1075 MHz+ GPU' footer {json(0,{hex_file(CUST,256,1)})} -json '[{"00":"0ff", "01":"On"}]' -set-ini-val './config.ini' '2295 MHz CPU' footer {json(0,{hex_file(CUST,264,1)})} - - -[cUpdate] -hex_file '/atmosphere/kips/loader.kip' -json_file './json/version.json' -set-ini-val './config.ini' 'Update loader.kip' footer {json_file(0,{hex_file(CUST,260,1)})} - -ini_file './package.ini' -set-ini-val './config.ini' 'Update OC Toolkit' footer '{ini_file(RAM Table package,;version)}' -download 'https://raw.githubusercontent.com/halop/OC-Switchcraft-EOS/main/OC%20Toolkit/package.ini' './tmp.ini' -ini_file './tmp.ini' -set-ini-val './config.ini' Update online '{ini_file(RAM Table package,;version)}' -delete './tmp.ini' - - - -[cBackupSystem] -mariko: -json_file './json/max_clocks.json' -ini_file '/atmosphere/kips/.bakTK/Slot 0.ini' -set-ini-val './config.ini' '*Slot 0' footer '{json_file(0,{ini_file(Backup,ramMHzM)})}' -ini_file '/atmosphere/kips/.bakTK/Slot 1.ini' -set-ini-val './config.ini' '*Slot 1' footer '{json_file(0,{ini_file(Backup,ramMHzM)})}' -ini_file '/atmosphere/kips/.bakTK/Slot 2.ini' -set-ini-val './config.ini' '*Slot 2' footer '{json_file(0,{ini_file(Backup,ramMHzM)})}' -ini_file '/atmosphere/kips/.bakTK/Slot 3.ini' -set-ini-val './config.ini' '*Slot 3' footer '{json_file(0,{ini_file(Backup,ramMHzM)})}' -ini_file '/atmosphere/kips/.bakTK/Slot 4.ini' -set-ini-val './config.ini' '*Slot 4' footer '{json_file(0,{ini_file(Backup,ramMHzM)})}' -ini_file '/atmosphere/kips/.bakTK/Slot 5.ini' -set-ini-val './config.ini' '*Slot 5' footer '{json_file(0,{ini_file(Backup,ramMHzM)})}' -ini_file '/atmosphere/kips/.bakTK/Slot 6.ini' -set-ini-val './config.ini' '*Slot 6' footer '{json_file(0,{ini_file(Backup,ramMHzM)})}' - -erista: -hex_file '/atmosphere/kips/loader.kip' -json_file './json/max_clocks.json' -ini_file '/atmosphere/kips/.bakTK/Slot 0.ini' -set-ini-val './config.ini' '*Slot 0' footer '{json_file(0,{ini_file(Backup,ramMHzE)})}' -ini_file '/atmosphere/kips/.bakTK/Slot 1.ini' -set-ini-val './config.ini' '*Slot 1' footer '{json_file(0,{ini_file(Backup,ramMHzE)})}' -ini_file '/atmosphere/kips/.bakTK/Slot 2.ini' -set-ini-val './config.ini' '*Slot 2' footer '{json_file(0,{ini_file(Backup,ramMHzE)})}' -ini_file '/atmosphere/kips/.bakTK/Slot 3.ini' -set-ini-val './config.ini' '*Slot 3' footer '{json_file(0,{ini_file(Backup,ramMHzE)})}' -ini_file '/atmosphere/kips/.bakTK/Slot 4.ini' -set-ini-val './config.ini' '*Slot 4' footer '{json_file(0,{ini_file(Backup,ramMHzE)})}' -ini_file '/atmosphere/kips/.bakTK/Slot 5.ini' -set-ini-val './config.ini' '*Slot 5' footer '{json_file(0,{ini_file(Backup,ramMHzE)})}' -ini_file '/atmosphere/kips/.bakTK/Slot 6.ini' -set-ini-val './config.ini' '*Slot 6' footer '{json_file(0,{ini_file(Backup,ramMHzE)})}' - - - -[backup] -hex_file '/atmosphere/kips/loader.kip' -delete '/atmosphere/kips/.bakTK/tmp.ini' -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup cpuBoost {hex_file(CUST,8,3)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup cpuUVL {hex_file(CUST,12,1)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup cpuUVH {hex_file(CUST,252,1)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup cpuVminE {hex_file(CUST,16,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup cpuVmaxE {hex_file(CUST,20,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup cpuVminL {hex_file(CUST,24,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup cpuVminH {hex_file(CUST,28,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup cpuVmaxM {hex_file(CUST,32,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup gpuUVE {hex_file(CUST,36,1)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup gpuUVM {hex_file(CUST,40,1)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup gpuOFF {hex_file(CUST,44,1)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup gpuVminE {hex_file(CUST,48,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup gpuSpeedo {hex_file(CUST,52,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup gpuVminM {hex_file(CUST,56,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup gpuVmax {hex_file(CUST,60,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup DRAM {hex_file(CUST,64,1)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup ramVDD2 {hex_file(CUST,68,3)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup ramVDDQ {hex_file(CUST,72,3)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup ramMHzE {hex_file(CUST,76,3)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup ramMHzM {hex_file(CUST,80,3)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup DVB {hex_file(CUST,84,4)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup T1 {hex_file(CUST,88,1)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup T2 {hex_file(CUST,92,1)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup T3 {hex_file(CUST,96,1)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup T4 {hex_file(CUST,100,1)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup T5 {hex_file(CUST,104,1)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup T6 {hex_file(CUST,108,1)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup T7 {hex_file(CUST,112,1)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup T8 {hex_file(CUST,116,1)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 76UV3 {hex_file(CUST,124,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 153UV3 {hex_file(CUST,128,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 230UV3 {hex_file(CUST,132,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 307UV3 {hex_file(CUST,136,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 384UV3 {hex_file(CUST,140,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 460UV3 {hex_file(CUST,144,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 537UV3 {hex_file(CUST,148,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 614UV3 {hex_file(CUST,152,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 691UV3 {hex_file(CUST,156,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 768UV3 {hex_file(CUST,160,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 844UV3 {hex_file(CUST,164,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 921UV3 {hex_file(CUST,168,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 998UV3 {hex_file(CUST,172,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 1075UV3 {hex_file(CUST,176,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 1152UV3 {hex_file(CUST,180,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 1228UV3 {hex_file(CUST,184,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 1267UV3 {hex_file(CUST,188,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 1305UV3 {hex_file(CUST,192,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 1344UV3 {hex_file(CUST,196,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 1382UV3 {hex_file(CUST,200,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 1420UV3 {hex_file(CUST,204,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 1459UV3 {hex_file(CUST,208,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 1497UV3 {hex_file(CUST,212,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 1536UV3 {hex_file(CUST,216,2)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup 1305GPU {hex_file(CUST,256,1)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup CPUUL {hex_file(CUST,264,1)} -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup CPUTABLE {hex_file(CUST,272,1)} -json_file './json/numbers.json' -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup Timings '({json_file(0,{hex_file(CUST,88,1)})}-{json_file(0,{hex_file(CUST,92,1)})}-{json_file(0,{hex_file(CUST,96,1)})}) {json_file(0,{hex_file(CUST,100,1)})}-{json_file(0,{hex_file(CUST,104,1)})}-{json_file(0,{hex_file(CUST,108,1)})}-{json_file(0,{hex_file(CUST,112,1)})}-{json_file(0,{hex_file(CUST,116,1)})}' -ini_file '/config/sys-clk/config.ini' -json_file './json/gpu_dvfs_offset_dec.json' -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup gpuDvfsO {json_file(0,{ini_file(values,gpu_dvfs_offset)})} -json '[{"null":"1", "0":"0", "1":"1", "2":"2"}]' -set-ini-val '/atmosphere/kips/.bakTK/tmp.ini' Backup gpuDvfs {json(0,{ini_file(values,gpu_dvfs)})} - -[restore] -ini_file '/atmosphere/kips/.bakTK/tmp.ini' -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 8 {ini_file(Backup,cpuBoost)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 12 {ini_file(Backup,cpuUVL)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 252 {ini_file(Backup,cpuUVH)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 16 {ini_file(Backup,cpuVminE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 20 {ini_file(Backup,cpuVmaxE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 24 {ini_file(Backup,cpuVminL)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 28 {ini_file(Backup,cpuVminH)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 32 {ini_file(Backup,cpuVmaxM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 36 {ini_file(Backup,gpuUVE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 40 {ini_file(Backup,gpuUVM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 44 {ini_file(Backup,gpuOFF)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 48 {ini_file(Backup,gpuVminE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 52 {ini_file(Backup,gpuSpeedo)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 56 {ini_file(Backup,gpuVminM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 60 {ini_file(Backup,gpuVmax)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 64 {ini_file(Backup,DRAM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 68 {ini_file(Backup,ramVDD2)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 72 {ini_file(Backup,ramVDDQ)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 76 {ini_file(Backup,ramMHzE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 80 {ini_file(Backup,ramMHzM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 84 {ini_file(Backup,DVB)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 {ini_file(Backup,T1)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 {ini_file(Backup,T2)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 {ini_file(Backup,T3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 {ini_file(Backup,T4)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 {ini_file(Backup,T5)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 {ini_file(Backup,T6)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 {ini_file(Backup,T7)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 {ini_file(Backup,T8)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 124 {ini_file(Backup,76UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 128 {ini_file(Backup,153UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 132 {ini_file(Backup,230UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 136 {ini_file(Backup,307UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 140 {ini_file(Backup,384UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 144 {ini_file(Backup,460UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 148 {ini_file(Backup,537UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 152 {ini_file(Backup,614UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 156 {ini_file(Backup,691UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 160 {ini_file(Backup,768UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 164 {ini_file(Backup,844UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 168 {ini_file(Backup,921UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 172 {ini_file(Backup,998UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 176 {ini_file(Backup,1075UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 180 {ini_file(Backup,1152UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 184 {ini_file(Backup,1228UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 188 {ini_file(Backup,1267UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 192 {ini_file(Backup,1305UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 196 {ini_file(Backup,1344UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 200 {ini_file(Backup,1382UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 204 {ini_file(Backup,1420UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 208 {ini_file(Backup,1459UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 212 {ini_file(Backup,1497UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 216 {ini_file(Backup,1536UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 256 {ini_file(Backup,1305GPU)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 264 {ini_file(Backup,CPUUL)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 272 {ini_file(Backup,CPUTABLE)} -json_file './json/gpu_dvfs_offset_dec.json' -set-ini-val /config/sys-clk/config.ini values gpu_dvfs_offset {json_file(0,{ini_file(Backup,gpuDvfsO)})} -json '[{"null":"2", "0":"0", "1":"1", "2":"2"}]' -set-ini-val /config/sys-clk/config.ini values gpu_dvfs {json(0,{ini_file(Backup,gpuDvfs)})} - -[cMariko_boot] -hex_file '/atmosphere/kips/loader.kip' - -json_file './json/max_clocks.json' -set-ini-val './config.ini' '*Max Clock?RAMmariko' footer {json_file(0,{hex_file(CUST,80,3)})} - -json_file './json/cpu_max_freq_index.json' -set-ini-val './config.ini' 'Max CPU Freq?mariko' index {json_file(0,{hex_file(CUST,264,1)})} - -json_file './json/vddq.json' -set-ini-val './config.ini' '*Vddq' footer {json_file(0,{hex_file(CUST,72,3)})} - -json_file './json/ram_dvb_index.json' -set-ini-val './config.ini' 'EMC DVB Table?mariko' index {json_file(0,{hex_file(CUST,84,1)})} - -json_file './json/numbers.json' -set-ini-val './config.ini' 'High Freq UV?CPU' index {json_file(0,{hex_file(CUST,252,1)})} -set-ini-val './config.ini' 'Undervolt Mode?GPUmariko' index {json_file(0,{hex_file(CUST,40,1)})} - -json_file './json/cpu_table.json' -set-ini-val './config.ini' '*Table Config?CPUmariko' footer {json_file(0,{hex_file(CUST,272,1)})} - -json_file './json/mv.json' -set-ini-val './config.ini' '*High Freq Vmin?CPUmariko' footer {json_file(0,{hex_file(CUST,28,2)})} -set-ini-val './config.ini' '*Low Freq Vmin?CPUmariko' footer {json_file(0,{hex_file(CUST,24,2)})} - -json_file './json/voltage_limit.json' -set-ini-val './config.ini' '*Voltage Limit?CPUmariko' footer {json_file(0,{hex_file(CUST,32,2)})} - -json_file './json/vmin.json' -set-ini-val './config.ini' '*Vmin?GPUmariko' footer {json_file(0,{hex_file(CUST,56,2)})} -set-ini-val './config.ini' '*Vmax?GPU' footer {json_file(0,{hex_file(CUST,60,2)})} - -ini_file '/config/sys-clk/config.ini' -json '[{"null":"1", "0":"0", "1":"1", "2":"2"}]' -set-ini-val './config.ini' 'DVFS' index {json(0,{ini_file(values,gpu_dvfs)})} - -json_file './json/gpu_dvfs_offset_index.json' -set-ini-val './config.ini' 'DVFS Offset?GPUmariko' index {json_file(0,{ini_file(values,gpu_dvfs_offset)})} - - -[cErista_boot] -hex_file '/atmosphere/kips/loader.kip' - -json_file './json/max_clocks.json' -set-ini-val './config.ini' '*Max Clock?RAMerista' footer {json_file(0,{hex_file(CUST,76,3)})} - -json_file './json/numbers.json' -set-ini-val './config.ini' 'EMC DVB Table?erista' index {json_file(0,{hex_file(CUST,84,1)})} -set-ini-val './config.ini' 'Undervolt Mode?GPUerista' index {json_file(0,{hex_file(CUST,36,1)})} - -json_file './json/mv.json' -set-ini-val './config.ini' '*Vmin?GPUerista' footer {json_file(0,{hex_file(CUST,48,2)})} -set-ini-val './config.ini' '*Vmin?CPUerista' footer {json_file(0,{hex_file(CUST,16,2)})} - -json_file './json/voltage_limit.json' -set-ini-val './config.ini' '*Voltage Limit?CPUerista' footer {json_file(0,{hex_file(CUST,20,2)})} - - - diff --git a/Ultrahand/OC Toolkit/custom_table.ini b/Ultrahand/OC Toolkit/custom_table.ini deleted file mode 100644 index 157b462a..00000000 --- a/Ultrahand/OC Toolkit/custom_table.ini +++ /dev/null @@ -1,239 +0,0 @@ -;creator='ppkantorski, B3711' - - -[Custom Table] -[*76 - 230 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 124 {json_file_source(*,hex)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 128 {json_file_source(*,hex)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 132 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 124 {json_file_source(*,hex)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 128 {json_file_source(*,hex)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 132 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*307 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 136 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 136 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*384 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 140 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 140 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*460 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 144 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 144 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*537 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 148 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 148 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*614 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 152 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 152 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*691 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 156 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 156 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*768 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 160 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 160 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*844 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 164 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 164 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*921 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 168 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 168 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*998 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 172 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 172 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*1075 MHz?GPUUV3mariko] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 176 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*1152 MHz?GPUUV3mariko] -;system=mariko -;mode=option -;mini=true -;selection_mini=true -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 180 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*1228 MHz?GPUUV3] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 184 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*1267 MHz?GPUUV3] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 188 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*1305 MHz?GPUUV3] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 192 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - - - -[Gap] -;system=mariko -;mode=table -;background=false -;header=false -;gap=20 - - -[*Default Table?GPUUV3] -;mode=forwarder -package_source './default_table.ini' diff --git a/Ultrahand/OC Toolkit/data/EOS/backup_info.ini b/Ultrahand/OC Toolkit/data/EOS/backup_info.ini deleted file mode 100644 index 18870af4..00000000 --- a/Ultrahand/OC Toolkit/data/EOS/backup_info.ini +++ /dev/null @@ -1,112 +0,0 @@ -;creator=ppkantorski, MestreYodaRossi, B3711 - - -[@Presets] -[RAM] -[RAM Table] -;mode=table -;spacing=4 -;gap=0 -ini_file '/atmosphere/kips/.bakTK/tmp.ini' -'Timings' = {ini_file(Backup,Timings)} -ini_file '/atmosphere/kips/.bakTK/tmp.ini' -json_file './json/dram.json' -'DRAM'= {json_file(0,{ini_file(Backup,DRAM)})} -mariko: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzM)})} -json_file './json/vddq.json' -'Vddq' = {json_file(0,{ini_file(Backup,ramVDDQ)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} -json_file './json/ram_dvb.json' -'EMC DVB' = {json_file(0,{ini_file(Backup,DVB)})} -erista: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzE)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} -json_file './json/ram_dvb.json' -'EMC DVB' = {json_file(0,{ini_file(Backup,DVB)})} - - -[CPU] -[CPU Table] -;mode=table -;spacing=4 -;gap=4 -ini_file '/atmosphere/kips/.bakTK/tmp.ini' -json_file './json/numbers.json' -'UV Level' = {json_file(0,{ini_file(Backup,cpuUVL)})} -mariko: -json_file './json/high_freq_uv.json' -'High Freq UV Level' = {json_file(0,{ini_file(Backup,cpuUVH)})} -json_file './json/cpu_table.json' -'Table Config' = {json_file(0,{ini_file(Backup,CPUTABLE)})} -json_file './json/mv.json' -'Low Freq Vmin' = {json_file(0,{ini_file(Backup,cpuVminL)})} -'High Freq Vmin' = {json_file(0,{ini_file(Backup,cpuVminH)})} -json_file './json/voltage_limit.json' -'Volt Limit' = {json_file(0,{ini_file(Backup,cpuVmaxM)})} -json_file './json/max_clocks.json' -'Boost Clock' = {json_file(0,{ini_file(Backup,cpuBoost)})} -json_file './json/cpu_max_clock_m.json' -'Max Clock' = {json_file(0,{ini_file(Backup,CPUUL)})} -erista: -json_file './json/mv.json' -'Vmin' = {json_file(0,{ini_file(Backup,cpuVminE)})} -json_file './json/voltage_limit.json' -'Volt Limit' = {json_file(0,{ini_file(Backup,cpuVmaxE)})} -json_file './json/max_clocks.json' -'Boost Clock' = {json_file(0,{ini_file(Backup,cpuBoost)})} - -[GPU] -[GPU Table] -;mode=table -;spacing=4 -;gap=0 -ini_file '/atmosphere/kips/.bakTK/tmp.ini' -mariko: -json_file './json/gpu_uv_m.json' -'UV Level' = {json_file(0,{ini_file(Backup,gpuUVM)})} -json_file './json/gpu_dvfs_offset_info.json' -'DVFS' = {json_file(0,{ini_file(Backup,gpuDvfsO)})} -json_file './json/vmin.json' -'Vmin' = {json_file(0,{ini_file(Backup,gpuVminM)})} -'Vmax' = {json_file(0,{ini_file(Backup,gpuVmax)})} -json_file './json/voltage_offset.json' -'Volt Offset' = {json_file(0,{ini_file(Backup,gpuOFF)})} -erista: -json_file './json/gpu_uv_e.json' -'UV Level' = {json_file(0,{ini_file(Backup,gpuUVE)})} -json_file './json/mv.json' -'Vmin' = {json_file(0,{ini_file(Backup,gpuVminE)})} -json_file './json/voltage_offset.json' -'Volt Offset' = {json_file(0,{ini_file(Backup,gpuOFF)})} -;gap=100 - -[@Custom Table] -[Custom Table] -[Custom Table] -;mode=table -;spacing=8 -;gap=0 -ini_file '/atmosphere/kips/.bakTK/tmp.ini' -json_file './json/vmin.json' -'76 - 230 MHz' = {json_file(0,{ini_file(Backup,230UV3)})} -'307 MHz' = {json_file(0,{ini_file(Backup,307UV3)})} -'384 MHz' = {json_file(0,{ini_file(Backup,384UV3)})} -'460 MHz' = {json_file(0,{ini_file(Backup,460UV3)})} -'537 MHz' = {json_file(0,{ini_file(Backup,537UV3)})} -'614 MHz' = {json_file(0,{ini_file(Backup,614UV3)})} -'691 MHz' = {json_file(0,{ini_file(Backup,691UV3)})} -'768 MHz' = {json_file(0,{ini_file(Backup,768UV3)})} -'844 MHz' = {json_file(0,{ini_file(Backup,844UV3)})} -'921 MHz' = {json_file(0,{ini_file(Backup,921UV3)})} -'998 MHz' = {json_file(0,{ini_file(Backup,998UV3)})} -mariko: -'1075 MHz' = {json_file(0,{ini_file(Backup,1075UV3)})} -'1152 MHz' = {json_file(0,{ini_file(Backup,1152UV3)})} -'1228 MHz' = {json_file(0,{ini_file(Backup,1228UV3)})} -'1267 MHz' = {json_file(0,{ini_file(Backup,1267UV3)})} -'1305 MHz' = {json_file(0,{ini_file(Backup,1305UV3)})} diff --git a/Ultrahand/OC Toolkit/data/EOS/custom_table.ini b/Ultrahand/OC Toolkit/data/EOS/custom_table.ini deleted file mode 100644 index 157b462a..00000000 --- a/Ultrahand/OC Toolkit/data/EOS/custom_table.ini +++ /dev/null @@ -1,239 +0,0 @@ -;creator='ppkantorski, B3711' - - -[Custom Table] -[*76 - 230 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 124 {json_file_source(*,hex)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 128 {json_file_source(*,hex)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 132 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 124 {json_file_source(*,hex)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 128 {json_file_source(*,hex)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 132 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*307 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 136 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 136 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*384 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 140 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 140 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*460 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 144 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 144 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*537 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 148 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 148 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*614 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 152 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 152 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*691 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 156 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 156 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*768 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 160 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 160 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*844 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 164 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 164 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*921 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 168 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 168 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*998 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 172 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 172 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*1075 MHz?GPUUV3mariko] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 176 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*1152 MHz?GPUUV3mariko] -;system=mariko -;mode=option -;mini=true -;selection_mini=true -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 180 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*1228 MHz?GPUUV3] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 184 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*1267 MHz?GPUUV3] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 188 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*1305 MHz?GPUUV3] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 192 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - - - -[Gap] -;system=mariko -;mode=table -;background=false -;header=false -;gap=20 - - -[*Default Table?GPUUV3] -;mode=forwarder -package_source './default_table.ini' diff --git a/Ultrahand/OC Toolkit/data/EOS/erista/gpu_uv3.json b/Ultrahand/OC Toolkit/data/EOS/erista/gpu_uv3.json deleted file mode 100644 index 16ec74b0..00000000 --- a/Ultrahand/OC Toolkit/data/EOS/erista/gpu_uv3.json +++ /dev/null @@ -1,267 +0,0 @@ -[ - { - "name": "Auto", - "hex": "0000", - "label": "Auto" - }, - { - "name": "disabled", - "hex": "D007", - "label": "disabled" - }, - { - "name": "700 mV", - "hex": "BC02", - "label": "700 mV" - }, - { - "name": "705 mV", - "hex": "C102", - "label": "705 mV" - }, - { - "name": "710 mV", - "hex": "C602", - "label": "710 mV" - }, - { - "name": "715 mV", - "hex": "CB02", - "label": "715 mV" - }, - { - "name": "720 mV", - "hex": "D002", - "label": "720 mV" - }, - { - "name": "725 mV", - "hex": "D502", - "label": "725 mV" - }, - { - "name": "730 mV", - "hex": "DA02", - "label": "730 mV" - }, - { - "name": "735 mV", - "hex": "DF02", - "label": "735 mV" - }, - { - "name": "740 mV", - "hex": "E402", - "label": "740 mV" - }, - { - "name": "745 mV", - "hex": "E902", - "label": "745 mV" - }, - { - "name": "750 mV", - "hex": "EE02", - "label": "750 mV" - }, - { - "name": "755 mV", - "hex": "F302", - "label": "755 mV" - }, - { - "name": "760 mV", - "hex": "F802", - "label": "760 mV" - }, - { - "name": "765 mV", - "hex": "FD02", - "label": "765 mV" - }, - { - "name": "770 mV", - "hex": "0203", - "label": "770 mV" - }, - { - "name": "775 mV", - "hex": "0703", - "label": "775 mV" - }, - { - "name": "780 mV", - "hex": "0C03", - "label": "780 mV" - }, - { - "name": "785 mV", - "hex": "1103", - "label": "785 mV" - }, - { - "name": "790 mV", - "hex": "1603", - "label": "790 mV" - }, - { - "name": "795 mV", - "hex": "1B03", - "label": "795 mV" - }, - { - "name": "800 mV", - "hex": "2003", - "label": "800 mV" - }, - { - "name": "805 mV", - "hex": "2503", - "label": "805 mV" - }, - { - "name": "810 mV", - "hex": "2A03", - "label": "810 mV" - }, - { - "name": "815 mV", - "hex": "2F03", - "label": "815 mV" - }, - { - "name": "820 mV", - "hex": "3403", - "label": "820 mV" - }, - { - "name": "825 mV", - "hex": "3903", - "label": "825 mV" - }, - { - "name": "830 mV", - "hex": "3E03", - "label": "830 mV" - }, - { - "name": "835 mV", - "hex": "4303", - "label": "835 mV" - }, - { - "name": "840 mV", - "hex": "4803", - "label": "840 mV" - }, - { - "name": "845 mV", - "hex": "4D03", - "label": "845 mV" - }, - { - "name": "850 mV", - "hex": "5203", - "label": "850 mV" - }, - { - "name": "855 mV", - "hex": "5703", - "label": "855 mV" - }, - { - "name": "860 mV", - "hex": "5C03", - "label": "860 mV" - }, - { - "name": "865 mV", - "hex": "6103", - "label": "865 mV" - }, - { - "name": "870 mV", - "hex": "6603", - "label": "870 mV" - }, - { - "name": "875 mV", - "hex": "6B03", - "label": "875 mV" - }, - { - "name": "880 mV", - "hex": "7003", - "label": "880 mV" - }, - { - "name": "885 mV", - "hex": "7503", - "label": "885 mV" - }, - { - "name": "890 mV", - "hex": "7A03", - "label": "890 mV" - }, - { - "name": "895 mV", - "hex": "7F03", - "label": "895 mV" - }, - { - "name": "900 mV", - "hex": "8403", - "label": "900 mV" - }, - { - "name": "905 mV", - "hex": "8903", - "label": "905 mV" - }, - { - "name": "910 mV", - "hex": "8E03", - "label": "910 mV" - }, - { - "name": "915 mV", - "hex": "9303", - "label": "915 mV" - }, - { - "name": "920 mV", - "hex": "9803", - "label": "920 mV" - }, - { - "name": "925 mV", - "hex": "9D03", - "label": "925 mV" - }, - { - "name": "930 mV", - "hex": "A203", - "label": "930 mV" - }, - { - "name": "935 mV", - "hex": "A703", - "label": "935 mV" - }, - { - "name": "940 mV", - "hex": "AC03", - "label": "940 mV" - }, - { - "name": "945 mV", - "hex": "B103", - "label": "945 mV" - }, - { - "name": "950 mV", - "hex": "B603", - "label": "950 mV" - } -] diff --git a/Ultrahand/OC Toolkit/data/EOS/erista/gpu_uv3_e.json b/Ultrahand/OC Toolkit/data/EOS/erista/gpu_uv3_e.json deleted file mode 100644 index ec871112..00000000 --- a/Ultrahand/OC Toolkit/data/EOS/erista/gpu_uv3_e.json +++ /dev/null @@ -1,262 +0,0 @@ -[ - { - "name": "disabled", - "hex": "D007", - "label": "disabled" - }, - { - "name": "700 mV", - "hex": "BC02", - "label": "700 mV" - }, - { - "name": "705 mV", - "hex": "C102", - "label": "705 mV" - }, - { - "name": "710 mV", - "hex": "C602", - "label": "710 mV" - }, - { - "name": "715 mV", - "hex": "CB02", - "label": "715 mV" - }, - { - "name": "720 mV", - "hex": "D002", - "label": "720 mV" - }, - { - "name": "725 mV", - "hex": "D502", - "label": "725 mV" - }, - { - "name": "730 mV", - "hex": "DA02", - "label": "730 mV" - }, - { - "name": "735 mV", - "hex": "DF02", - "label": "735 mV" - }, - { - "name": "740 mV", - "hex": "E402", - "label": "740 mV" - }, - { - "name": "745 mV", - "hex": "E902", - "label": "745 mV" - }, - { - "name": "750 mV", - "hex": "EE02", - "label": "750 mV" - }, - { - "name": "755 mV", - "hex": "F302", - "label": "755 mV" - }, - { - "name": "760 mV", - "hex": "F802", - "label": "760 mV" - }, - { - "name": "765 mV", - "hex": "FD02", - "label": "765 mV" - }, - { - "name": "770 mV", - "hex": "0203", - "label": "770 mV" - }, - { - "name": "775 mV", - "hex": "0703", - "label": "775 mV" - }, - { - "name": "780 mV", - "hex": "0C03", - "label": "780 mV" - }, - { - "name": "785 mV", - "hex": "1103", - "label": "785 mV" - }, - { - "name": "790 mV", - "hex": "1603", - "label": "790 mV" - }, - { - "name": "795 mV", - "hex": "1B03", - "label": "795 mV" - }, - { - "name": "800 mV", - "hex": "2003", - "label": "800 mV" - }, - { - "name": "805 mV", - "hex": "2503", - "label": "805 mV" - }, - { - "name": "810 mV", - "hex": "2A03", - "label": "810 mV" - }, - { - "name": "815 mV", - "hex": "2F03", - "label": "815 mV" - }, - { - "name": "820 mV", - "hex": "3403", - "label": "820 mV" - }, - { - "name": "825 mV", - "hex": "3903", - "label": "825 mV" - }, - { - "name": "830 mV", - "hex": "3E03", - "label": "830 mV" - }, - { - "name": "835 mV", - "hex": "4303", - "label": "835 mV" - }, - { - "name": "840 mV", - "hex": "4803", - "label": "840 mV" - }, - { - "name": "845 mV", - "hex": "4D03", - "label": "845 mV" - }, - { - "name": "850 mV", - "hex": "5203", - "label": "850 mV" - }, - { - "name": "855 mV", - "hex": "5703", - "label": "855 mV" - }, - { - "name": "860 mV", - "hex": "5C03", - "label": "860 mV" - }, - { - "name": "865 mV", - "hex": "6103", - "label": "865 mV" - }, - { - "name": "870 mV", - "hex": "6603", - "label": "870 mV" - }, - { - "name": "875 mV", - "hex": "6B03", - "label": "875 mV" - }, - { - "name": "880 mV", - "hex": "7003", - "label": "880 mV" - }, - { - "name": "885 mV", - "hex": "7503", - "label": "885 mV" - }, - { - "name": "890 mV", - "hex": "7A03", - "label": "890 mV" - }, - { - "name": "895 mV", - "hex": "7F03", - "label": "895 mV" - }, - { - "name": "900 mV", - "hex": "8403", - "label": "900 mV" - }, - { - "name": "905 mV", - "hex": "8903", - "label": "905 mV" - }, - { - "name": "910 mV", - "hex": "8E03", - "label": "910 mV" - }, - { - "name": "915 mV", - "hex": "9303", - "label": "915 mV" - }, - { - "name": "920 mV", - "hex": "9803", - "label": "920 mV" - }, - { - "name": "925 mV", - "hex": "9D03", - "label": "925 mV" - }, - { - "name": "930 mV", - "hex": "A203", - "label": "930 mV" - }, - { - "name": "935 mV", - "hex": "A703", - "label": "935 mV" - }, - { - "name": "940 mV", - "hex": "AC03", - "label": "940 mV" - }, - { - "name": "945 mV", - "hex": "B103", - "label": "945 mV" - }, - { - "name": "950 mV", - "hex": "B603", - "label": "950 mV" - } -] diff --git a/Ultrahand/OC Toolkit/data/EOS/erista/ram_vdd2.json b/Ultrahand/OC Toolkit/data/EOS/erista/ram_vdd2.json deleted file mode 100644 index b68569e5..00000000 --- a/Ultrahand/OC Toolkit/data/EOS/erista/ram_vdd2.json +++ /dev/null @@ -1,87 +0,0 @@ -[ - { - "name": "Do not override", - "label": "Do not override", - "hex": "000000" - }, - { - "name": "1050 mV", - "label": "1050 mV", - "hex": "900510" - }, - { - "name": "1062.5 mV", - "label": "1062.5 mV", - "hex": "643610" - }, - { - "name": "1075 mV", - "label": "1075 mV", - "hex": "386710" - }, - { - "name": "1087.5 mV", - "label": "1087.5 mV", - "hex": "0C9810" - }, - { - "name": "1100 mV", - "label": "1100 mV", - "hex": "E0C810" - }, - { - "name": "1112.5 mV", - "label": "1112.5 mV", - "hex": "B4F910" - }, - { - "name": "1125 mV", - "label": "1125 mV - default", - "hex": "882A11" - }, - { - "name": "1137.5 mV", - "label": "1137.5 mV", - "hex": "5C5B11" - }, - { - "name": "1150 mV", - "label": "1150 mV", - "hex": "308C11" - }, - { - "name": "1162.5 mV", - "label": "1162.5 mV", - "hex": "04BD11" - }, - { - "name": "1175 mV", - "label": "1175 mV", - "hex": "D8ED11" - }, - { - "name": "1187.5 mV", - "label": "1187.5 mV", - "hex": "AC1E12" - }, - { - "name": "1200 mV", - "label": "1200 mV", - "hex": "804F12" - }, - { - "name": "1212.5 mV", - "label": "1212.5 mV", - "hex": "548012" - }, - { - "name": "1225 mV", - "label": "1225 mV - unsafe", - "hex": "28B112" - }, - { - "name": "1237.5 mV", - "label": "1237.5 mV - unsafe", - "hex": "FCE112" - } -] diff --git a/Ultrahand/OC Toolkit/data/EOS/info.ini b/Ultrahand/OC Toolkit/data/EOS/info.ini deleted file mode 100644 index 49d950c1..00000000 --- a/Ultrahand/OC Toolkit/data/EOS/info.ini +++ /dev/null @@ -1,193 +0,0 @@ -;creator=ppkantorski, MestreYodaRossi, B3711 -;show_version=true - - -[@Presets] -[RAM Table package Info] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -json_file './json/ram_model.json' -'RAM' = '{json_file(0,{ram_model})}' - - -[RAM Table] -;mode=table -;spacing=4 -;gap=0 -hex_file '/atmosphere/kips/loader.kip' -json_file './json/numbers.json' -'Timings' = '({json_file(0,{hex_file(CUST,88,1)})}-{json_file(0,{hex_file(CUST,92,1)})}-{json_file(0,{hex_file(CUST,96,1)})}) {json_file(0,{hex_file(CUST,100,1)})}-{json_file(0,{hex_file(CUST,104,1)})}-{json_file(0,{hex_file(CUST,108,1)})}-{json_file(0,{hex_file(CUST,112,1)})}-{json_file(0,{hex_file(CUST,116,1)})}' - -hex_file '/atmosphere/kips/loader.kip' -json_file './json/dram.json' -'DRAM'= {json_file(0,{hex_file(CUST,64,1)})} -mariko: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{hex_file(CUST,80,3)})} -json_file './json/vddq.json' -'Vddq' = {json_file(0,{hex_file(CUST,72,3)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{hex_file(CUST,68,3)})} -json_file './json/ram_dvb.json' -'EMC DVB' = {json_file(0,{hex_file(CUST,84,1)})} -erista: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{hex_file(CUST,76,3)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{hex_file(CUST,68,3)})} -json_file './json/ram_dvb.json' -'EMC DVB' = {json_file(0,{hex_file(CUST,84,1)})} - -[gap] -;mode=table -;background=false -;gap=25 - -[CPU Table package Info] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -'CPU' = '{cpu_speedo}' - -[CPU Table] -;mode=table -;spacing=4 -;gap=0 -hex_file '/atmosphere/kips/loader.kip' -json_file './json/numbers.json' -'UV Level' = {json_file(0,{hex_file(CUST,12,1)})} -mariko: -json_file './json/high_freq_uv.json' -'High Freq UV Level' = {json_file(0,{hex_file(CUST,252,1)})} -json_file './json/cpu_table.json' -'Table Config' = {json_file(0,{hex_file(CUST,272,1)})} -json_file './json/mv.json' -'Low Freq Vmin' = {json_file(0,{hex_file(CUST,24,2)})} -'High Freq Vmin' = {json_file(0,{hex_file(CUST,28,2)})} -json_file './json/voltage_limit.json' -'Volt Limit' = {json_file(0,{hex_file(CUST,32,2)})} -json_file './json/max_clocks.json' -'Boost Clock' = {json_file(0,{hex_file(CUST,8,3)})} -json_file './json/cpu_max_clock_m.json' -'Max Clock' = {json_file(0,{hex_file(CUST,264,1)})} -erista: -json_file './json/mv.json' -'Vmin' = {json_file(0,{hex_file(CUST,16,2)})} -json_file './json/voltage_limit.json' -'Volt Limit' = {json_file(0,{hex_file(CUST,20,2)})} -json_file './json/max_clocks.json' -'Boost Clock' = {json_file(0,{hex_file(CUST,8,3)})} - -[gap] -;mode=table -;background=false -;gap=25 - -[GPU Table package Info] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -'GPU' = '{gpu_speedo}' - -[GPU Table] -;mode=table -;spacing=4 -;gap=0 -hex_file '/atmosphere/kips/loader.kip' -mariko: -json_file './json/gpu_uv_m.json' -'UV Level' = {json_file(0,{hex_file(CUST,40,1)})} -ini_file '/config/sys-clk/config.ini' -json_file './json/gpu_dvfs_offset_info.json' -'DVFS' = {json_file(0,{ini_file(values,gpu_dvfs_offset)})} -json_file './json/vmin.json' -'Vmin' = {json_file(0,{hex_file(CUST,56,2)})} -'Vmax' = {json_file(0,{hex_file(CUST,60,2)})} -json_file './json/voltage_offset.json' -'Volt Offset' = {json_file(0,{hex_file(CUST,44,1)})} -erista: -json_file './json/gpu_uv_e.json' -'UV Level' = {json_file(0,{hex_file(CUST,36,1)})} -json_file './json/mv.json' -'Vmin' = {json_file(0,{hex_file(CUST,48,2)})} -json_file './json/voltage_offset.json' -'Volt Offset' = {json_file(0,{hex_file(CUST,44,1)})} -;gap=100 - -[@Custom Table] -[Custom Table] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -hex_file '/atmosphere/kips/loader.kip' -json_file './json/version.json' -'Custom Table' = '{json_file(0,{hex_file(CUST,260,1)})} kip' - -[Custom Table] -;mode=table -;spacing=5 -;gap=24 -hex_file '/atmosphere/kips/loader.kip' -json_file './json/vmin.json' -'76 - 230 MHz' = {json_file(0,{hex_file(CUST,132,2)})} -'307 MHz' = {json_file(0,{hex_file(CUST,136,2)})} -'384 MHz' = {json_file(0,{hex_file(CUST,140,2)})} -'460 MHz' = {json_file(0,{hex_file(CUST,144,2)})} -'537 MHz' = {json_file(0,{hex_file(CUST,148,2)})} -'614 MHz' = {json_file(0,{hex_file(CUST,152,2)})} -'691 MHz' = {json_file(0,{hex_file(CUST,156,2)})} -'768 MHz' = {json_file(0,{hex_file(CUST,160,2)})} -'844 MHz' = {json_file(0,{hex_file(CUST,164,2)})} -'921 MHz' = {json_file(0,{hex_file(CUST,168,2)})} -'998 MHz' = {json_file(0,{hex_file(CUST,172,2)})} -mariko: -'1075 MHz' = {json_file(0,{hex_file(CUST,176,2)})} -'1152 MHz' = {json_file(0,{hex_file(CUST,180,2)})} -'1228 MHz' = {json_file(0,{hex_file(CUST,184,2)})} -'1267 MHz' = {json_file(0,{hex_file(CUST,188,2)})} -'1305 MHz' = {json_file(0,{hex_file(CUST,192,2)})} - - -[Speedos1] -;mode=table -;background=false -;spacing=4 -;gap=15 -;header_indent=true -;info_text_color=header -;section_text_color=header -'Device Info' = ' CPU GPU SOC' - -[Speedos2] -;mode=table -;spacing=4 -;gap=25 -'Speedo' = '{cpu_speedo} | {gpu_speedo} | {soc_speedo}' -mariko: -'IDDQ' = ' {cpu_iddq} | {gpu_iddq} | {soc_iddq}' -erista: -'IDDQ' = ' {cpu_iddq} | {gpu_iddq} | {soc_iddq}' - -[Device Info Table] -;mode=table -;spacing=4 -;gap=15 -'Firmware' = 'HOS {hos_version} | AMS {ams_version}' -'RAM' = '{ram_model}' \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/data/EOS/mariko/cpu_voltages.json b/Ultrahand/OC Toolkit/data/EOS/mariko/cpu_voltages.json deleted file mode 100644 index ffb1f076..00000000 --- a/Ultrahand/OC Toolkit/data/EOS/mariko/cpu_voltages.json +++ /dev/null @@ -1,67 +0,0 @@ -[ - { - "name": "1100 mV", - "label": "1100 mV", - "hex": "4C04" - }, - { - "name": "1105 mV", - "label": "1105 mV", - "hex": "5104" - }, - { - "name": "1110 mV", - "label": "1110 mV", - "hex": "5604" - }, - { - "name": "1115 mV", - "label": "1115 mV", - "hex": "5B04" - }, - { - "name": "1120 mV", - "label": "1120 mV - default", - "hex": "6004" - }, - { - "name": "1125 mV", - "label": "1125 mV", - "hex": "6504" - }, - { - "name": "1130 mV", - "label": "1130 mV", - "hex": "6A04" - }, - { - "name": "1135 mV", - "label": "1135 mV", - "hex": "6F04" - }, - { - "name": "1140 mV", - "label": "1140 mV", - "hex": "7404" - }, - { - "name": "1145 mV", - "label": "1145 mV", - "hex": "7904" - }, - { - "name": "1150 mV", - "label": "1150 mV", - "hex": "7E04" - }, - { - "name": "1155 mV", - "label": "1155 mV", - "hex": "8304" - }, - { - "name": "1160 mV", - "label": "1160 mV", - "hex": "8804" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/data/EOS/mariko/gpu_uv3.json b/Ultrahand/OC Toolkit/data/EOS/mariko/gpu_uv3.json deleted file mode 100644 index cf5a6569..00000000 --- a/Ultrahand/OC Toolkit/data/EOS/mariko/gpu_uv3.json +++ /dev/null @@ -1,387 +0,0 @@ -[ - { - "name": "Auto", - "hex": "0000", - "label": "Auto" - }, - { - "name": "disabled", - "hex": "D007", - "label": "disabled" - }, - { - "name": "480 mV", - "hex": "E001", - "label": "480 mV" - }, - { - "name": "485 mV", - "hex": "E501", - "label": "485 mV" - }, - { - "name": "490 mV", - "hex": "EA01", - "label": "490 mV" - }, - { - "name": "495 mV", - "hex": "EF01", - "label": "495 mV" - }, - { - "name": "500 mV", - "hex": "F401", - "label": "500 mV" - }, - { - "name": "505 mV", - "hex": "F901", - "label": "505 mV" - }, - { - "name": "510 mV", - "hex": "FE01", - "label": "510 mV" - }, - { - "name": "515 mV", - "hex": "0302", - "label": "515 mV" - }, - { - "name": "520 mV", - "hex": "0802", - "label": "520 mV" - }, - { - "name": "525 mV", - "hex": "0D02", - "label": "525 mV" - }, - { - "name": "530 mV", - "hex": "1202", - "label": "530 mV" - }, - { - "name": "535 mV", - "hex": "1702", - "label": "535 mV" - }, - { - "name": "540 mV", - "hex": "1C02", - "label": "540 mV" - }, - { - "name": "545 mV", - "hex": "2102", - "label": "545 mV" - }, - { - "name": "550 mV", - "hex": "2602", - "label": "550 mV" - }, - { - "name": "555 mV", - "hex": "2B02", - "label": "555 mV" - }, - { - "name": "560 mV", - "hex": "3002", - "label": "560 mV" - }, - { - "name": "565 mV", - "hex": "3502", - "label": "565 mV" - }, - { - "name": "570 mV", - "hex": "3A02", - "label": "570 mV" - }, - { - "name": "575 mV", - "hex": "3F02", - "label": "575 mV" - }, - { - "name": "580 mV", - "hex": "4402", - "label": "580 mV" - }, - { - "name": "585 mV", - "hex": "4902", - "label": "585 mV" - }, - { - "name": "590 mV", - "hex": "4E02", - "label": "590 mV" - }, - { - "name": "595 mV", - "hex": "5302", - "label": "595 mV" - }, - { - "name": "600 mV", - "hex": "5802", - "label": "600 mV" - }, - { - "name": "605 mV", - "hex": "5D02", - "label": "605 mV" - }, - { - "name": "610 mV", - "hex": "6202", - "label": "610 mV" - }, - { - "name": "615 mV", - "hex": "6702", - "label": "615 mV" - }, - { - "name": "620 mV", - "hex": "6C02", - "label": "620 mV" - }, - { - "name": "625 mV", - "hex": "7102", - "label": "625 mV" - }, - { - "name": "630 mV", - "hex": "7602", - "label": "630 mV" - }, - { - "name": "635 mV", - "hex": "7B02", - "label": "635 mV" - }, - { - "name": "640 mV", - "hex": "8002", - "label": "640 mV" - }, - { - "name": "645 mV", - "hex": "8502", - "label": "645 mV" - }, - { - "name": "650 mV", - "hex": "8A02", - "label": "650 mV" - }, - { - "name": "655 mV", - "hex": "8F02", - "label": "655 mV" - }, - { - "name": "660 mV", - "hex": "9402", - "label": "660 mV" - }, - { - "name": "665 mV", - "hex": "9902", - "label": "665 mV" - }, - { - "name": "670 mV", - "hex": "9E02", - "label": "670 mV" - }, - { - "name": "675 mV", - "hex": "A302", - "label": "675 mV" - }, - { - "name": "680 mV", - "hex": "A802", - "label": "680 mV" - }, - { - "name": "685 mV", - "hex": "AD02", - "label": "685 mV" - }, - { - "name": "690 mV", - "hex": "B202", - "label": "690 mV" - }, - { - "name": "695 mV", - "hex": "B702", - "label": "695 mV" - }, - { - "name": "700 mV", - "hex": "BC02", - "label": "700 mV" - }, - { - "name": "705 mV", - "hex": "C102", - "label": "705 mV" - }, - { - "name": "710 mV", - "hex": "C602", - "label": "710 mV" - }, - { - "name": "715 mV", - "hex": "CB02", - "label": "715 mV" - }, - { - "name": "720 mV", - "hex": "D002", - "label": "720 mV" - }, - { - "name": "725 mV", - "hex": "D502", - "label": "725 mV" - }, - { - "name": "730 mV", - "hex": "DA02", - "label": "730 mV" - }, - { - "name": "735 mV", - "hex": "DF02", - "label": "735 mV" - }, - { - "name": "740 mV", - "hex": "E402", - "label": "740 mV" - }, - { - "name": "745 mV", - "hex": "E902", - "label": "745 mV" - }, - { - "name": "750 mV", - "hex": "EE02", - "label": "750 mV" - }, - { - "name": "755 mV", - "hex": "F302", - "label": "755 mV" - }, - { - "name": "760 mV", - "hex": "F802", - "label": "760 mV" - }, - { - "name": "765 mV", - "hex": "FD02", - "label": "765 mV" - }, - { - "name": "770 mV", - "hex": "0203", - "label": "770 mV" - }, - { - "name": "775 mV", - "hex": "0703", - "label": "775 mV" - }, - { - "name": "780 mV", - "hex": "0C03", - "label": "780 mV" - }, - { - "name": "785 mV", - "hex": "1103", - "label": "785 mV" - }, - { - "name": "790 mV", - "hex": "1603", - "label": "790 mV" - }, - { - "name": "795 mV", - "hex": "1B03", - "label": "795 mV" - }, - { - "name": "800 mV", - "hex": "2003", - "label": "800 mV - unsafe" - }, - { - "name": "805 mV", - "hex": "2503", - "label": "805 mV - unsafe" - }, - { - "name": "810 mV", - "hex": "2A03", - "label": "810 mV - unsafe" - }, - { - "name": "815 mV", - "hex": "2F03", - "label": "815 mV - unsafe" - }, - { - "name": "820 mV", - "hex": "3403", - "label": "820 mV - unsafe" - }, - { - "name": "825 mV", - "hex": "3903", - "label": "825 mV - unsafe" - }, - { - "name": "830 mV", - "hex": "3E03", - "label": "830 mV - unsafe" - }, - { - "name": "835 mV", - "hex": "4303", - "label": "835 mV - unsafe" - }, - { - "name": "840 mV", - "hex": "4803", - "label": "840 mV - unsafe" - }, - { - "name": "845 mV", - "hex": "4D03", - "label": "845 mV - unsafe" - }, - { - "name": "850 mV", - "hex": "5203", - "label": "850 mV - unsafe" - } -] diff --git a/Ultrahand/OC Toolkit/data/EOS/mariko/gpu_uv3_e.json b/Ultrahand/OC Toolkit/data/EOS/mariko/gpu_uv3_e.json deleted file mode 100644 index 01254319..00000000 --- a/Ultrahand/OC Toolkit/data/EOS/mariko/gpu_uv3_e.json +++ /dev/null @@ -1,382 +0,0 @@ -[ - { - "name": "disabled", - "hex": "D007", - "label": "disabled" - }, - { - "name": "480 mV", - "hex": "E001", - "label": "480 mV" - }, - { - "name": "485 mV", - "hex": "E501", - "label": "485 mV" - }, - { - "name": "490 mV", - "hex": "EA01", - "label": "490 mV" - }, - { - "name": "495 mV", - "hex": "EF01", - "label": "495 mV" - }, - { - "name": "500 mV", - "hex": "F401", - "label": "500 mV" - }, - { - "name": "505 mV", - "hex": "F901", - "label": "505 mV" - }, - { - "name": "510 mV", - "hex": "FE01", - "label": "510 mV" - }, - { - "name": "515 mV", - "hex": "0302", - "label": "515 mV" - }, - { - "name": "520 mV", - "hex": "0802", - "label": "520 mV" - }, - { - "name": "525 mV", - "hex": "0D02", - "label": "525 mV" - }, - { - "name": "530 mV", - "hex": "1202", - "label": "530 mV" - }, - { - "name": "535 mV", - "hex": "1702", - "label": "535 mV" - }, - { - "name": "540 mV", - "hex": "1C02", - "label": "540 mV" - }, - { - "name": "545 mV", - "hex": "2102", - "label": "545 mV" - }, - { - "name": "550 mV", - "hex": "2602", - "label": "550 mV" - }, - { - "name": "555 mV", - "hex": "2B02", - "label": "555 mV" - }, - { - "name": "560 mV", - "hex": "3002", - "label": "560 mV" - }, - { - "name": "565 mV", - "hex": "3502", - "label": "565 mV" - }, - { - "name": "570 mV", - "hex": "3A02", - "label": "570 mV" - }, - { - "name": "575 mV", - "hex": "3F02", - "label": "575 mV" - }, - { - "name": "580 mV", - "hex": "4402", - "label": "580 mV" - }, - { - "name": "585 mV", - "hex": "4902", - "label": "585 mV" - }, - { - "name": "590 mV", - "hex": "4E02", - "label": "590 mV" - }, - { - "name": "595 mV", - "hex": "5302", - "label": "595 mV" - }, - { - "name": "600 mV", - "hex": "5802", - "label": "600 mV" - }, - { - "name": "605 mV", - "hex": "5D02", - "label": "605 mV" - }, - { - "name": "610 mV", - "hex": "6202", - "label": "610 mV" - }, - { - "name": "615 mV", - "hex": "6702", - "label": "615 mV" - }, - { - "name": "620 mV", - "hex": "6C02", - "label": "620 mV" - }, - { - "name": "625 mV", - "hex": "7102", - "label": "625 mV" - }, - { - "name": "630 mV", - "hex": "7602", - "label": "630 mV" - }, - { - "name": "635 mV", - "hex": "7B02", - "label": "635 mV" - }, - { - "name": "640 mV", - "hex": "8002", - "label": "640 mV" - }, - { - "name": "645 mV", - "hex": "8502", - "label": "645 mV" - }, - { - "name": "650 mV", - "hex": "8A02", - "label": "650 mV" - }, - { - "name": "655 mV", - "hex": "8F02", - "label": "655 mV" - }, - { - "name": "660 mV", - "hex": "9402", - "label": "660 mV" - }, - { - "name": "665 mV", - "hex": "9902", - "label": "665 mV" - }, - { - "name": "670 mV", - "hex": "9E02", - "label": "670 mV" - }, - { - "name": "675 mV", - "hex": "A302", - "label": "675 mV" - }, - { - "name": "680 mV", - "hex": "A802", - "label": "680 mV" - }, - { - "name": "685 mV", - "hex": "AD02", - "label": "685 mV" - }, - { - "name": "690 mV", - "hex": "B202", - "label": "690 mV" - }, - { - "name": "695 mV", - "hex": "B702", - "label": "695 mV" - }, - { - "name": "700 mV", - "hex": "BC02", - "label": "700 mV" - }, - { - "name": "705 mV", - "hex": "C102", - "label": "705 mV" - }, - { - "name": "710 mV", - "hex": "C602", - "label": "710 mV" - }, - { - "name": "715 mV", - "hex": "CB02", - "label": "715 mV" - }, - { - "name": "720 mV", - "hex": "D002", - "label": "720 mV" - }, - { - "name": "725 mV", - "hex": "D502", - "label": "725 mV" - }, - { - "name": "730 mV", - "hex": "DA02", - "label": "730 mV" - }, - { - "name": "735 mV", - "hex": "DF02", - "label": "735 mV" - }, - { - "name": "740 mV", - "hex": "E402", - "label": "740 mV" - }, - { - "name": "745 mV", - "hex": "E902", - "label": "745 mV" - }, - { - "name": "750 mV", - "hex": "EE02", - "label": "750 mV" - }, - { - "name": "755 mV", - "hex": "F302", - "label": "755 mV" - }, - { - "name": "760 mV", - "hex": "F802", - "label": "760 mV" - }, - { - "name": "765 mV", - "hex": "FD02", - "label": "765 mV" - }, - { - "name": "770 mV", - "hex": "0203", - "label": "770 mV" - }, - { - "name": "775 mV", - "hex": "0703", - "label": "775 mV" - }, - { - "name": "780 mV", - "hex": "0C03", - "label": "780 mV" - }, - { - "name": "785 mV", - "hex": "1103", - "label": "785 mV" - }, - { - "name": "790 mV", - "hex": "1603", - "label": "790 mV" - }, - { - "name": "795 mV", - "hex": "1B03", - "label": "795 mV" - }, - { - "name": "800 mV", - "hex": "2003", - "label": "800 mV - unsafe" - }, - { - "name": "805 mV", - "hex": "2503", - "label": "805 mV - unsafe" - }, - { - "name": "810 mV", - "hex": "2A03", - "label": "810 mV - unsafe" - }, - { - "name": "815 mV", - "hex": "2F03", - "label": "815 mV - unsafe" - }, - { - "name": "820 mV", - "hex": "3403", - "label": "820 mV - unsafe" - }, - { - "name": "825 mV", - "hex": "3903", - "label": "825 mV - unsafe" - }, - { - "name": "830 mV", - "hex": "3E03", - "label": "830 mV - unsafe" - }, - { - "name": "835 mV", - "hex": "4303", - "label": "835 mV - unsafe" - }, - { - "name": "840 mV", - "hex": "4803", - "label": "840 mV - unsafe" - }, - { - "name": "845 mV", - "hex": "4D03", - "label": "845 mV - unsafe" - }, - { - "name": "850 mV", - "hex": "5203", - "label": "850 mV - unsafe" - } -] diff --git a/Ultrahand/OC Toolkit/data/EOS/mariko/gpu_vmax.json b/Ultrahand/OC Toolkit/data/EOS/mariko/gpu_vmax.json deleted file mode 100644 index 1ec54f94..00000000 --- a/Ultrahand/OC Toolkit/data/EOS/mariko/gpu_vmax.json +++ /dev/null @@ -1,46 +0,0 @@ -[ - { - "name": "800 mV", - "hex": "2003" - }, - { - "name": "805 mV", - "hex": "2503" - }, - { - "name": "810 mV", - "hex": "2A03" - }, - { - "name": "815 mV", - "hex": "2F03" - }, - { - "name": "820 mV", - "hex": "3403" - }, - { - "name": "825 mV", - "hex": "3903" - }, - { - "name": "830 mV", - "hex": "3E03" - }, - { - "name": "835 mV", - "hex": "4303" - }, - { - "name": "840 mV", - "hex": "4803" - }, - { - "name": "845 mV", - "hex": "4D03" - }, - { - "name": "850 mV", - "hex": "5203" - } -] diff --git a/Ultrahand/OC Toolkit/data/EOS/mariko/ram_vdd2.json b/Ultrahand/OC Toolkit/data/EOS/mariko/ram_vdd2.json deleted file mode 100644 index 1f12cc94..00000000 --- a/Ultrahand/OC Toolkit/data/EOS/mariko/ram_vdd2.json +++ /dev/null @@ -1,77 +0,0 @@ -[ - { - "name": "Do not override", - "label": "Do not override", - "hex": "000000" - }, - { - "name": "1050 mV", - "label": "1050 mV", - "hex": "900510" - }, - { - "name": "1062.5 mV", - "label": "1062.5 mV", - "hex": "643610" - }, - { - "name": "1075 mV", - "label": "1075 mV", - "hex": "386710" - }, - { - "name": "1087.5 mV", - "label": "1087.5 mV", - "hex": "0C9810" - }, - { - "name": "1100 mV", - "label": "1100 mV - default", - "hex": "E0C810" - }, - { - "name": "1112.5 mV", - "label": "1112.5 mV", - "hex": "B4F910" - }, - { - "name": "1125 mV", - "label": "1125 mV", - "hex": "882A11" - }, - { - "name": "1137.5 mV", - "label": "1137.5 mV", - "hex": "5C5B11" - }, - { - "name": "1150 mV", - "label": "1150 mV", - "hex": "308C11" - }, - { - "name": "1162.5 mV", - "label": "1162.5 mV", - "hex": "04BD11" - }, - { - "name": "1175 mV", - "label": "1175 mV", - "hex": "D8ED11" - }, - { - "name": "1187.5 mV", - "label": "1187.5 mV", - "hex": "AC1E12" - }, - { - "name": "1200 mV", - "label": "1200 mV", - "hex": "804F12" - }, - { - "name": "1212.5 mV", - "label": "1212.5 mV", - "hex": "548012" - } -] diff --git a/Ultrahand/OC Toolkit/data/EOS/mariko/ram_vddq.json b/Ultrahand/OC Toolkit/data/EOS/mariko/ram_vddq.json deleted file mode 100644 index 896f6975..00000000 --- a/Ultrahand/OC Toolkit/data/EOS/mariko/ram_vddq.json +++ /dev/null @@ -1,112 +0,0 @@ -[ - { - "name": "Do not override", - "label": "Do not override", - "hex": "000000" - }, - { - "name": "550 mV", - "label": "550 mV", - "hex": "706408" - }, - { - "name": "555 mV", - "label": "555 mV", - "hex": "F87708" - }, - { - "name": "560 mV", - "label": "560 mV", - "hex": "808B08" - }, - { - "name": "565 mV", - "label": "565 mV", - "hex": "089F08" - }, - { - "name": "570 mV", - "label": "570 mV", - "hex": "90B208" - }, - { - "name": "575 mV", - "label": "575 mV", - "hex": "18C608" - }, - { - "name": "580 mV", - "label": "580 mV", - "hex": "A0D908" - }, - { - "name": "585 mV", - "label": "585 mV", - "hex": "28ED08" - }, - { - "name": "590 mV", - "label": "590 mV", - "hex": "B00009" - }, - { - "name": "595 mV", - "label": "595 mV", - "hex": "381409" - }, - { - "name": "600 mV", - "label": "600 mV - default", - "hex": "C02709" - }, - { - "name": "605 mV", - "label": "605 mV", - "hex": "483B09" - }, - { - "name": "610 mV", - "label": "610 mV", - "hex": "D04E09" - }, - { - "name": "615 mV", - "label": "615 mV", - "hex": "586209" - }, - { - "name": "620 mV", - "label": "620 mV", - "hex": "E07509" - }, - { - "name": "625 mV", - "label": "625 mV", - "hex": "688909" - }, - { - "name": "630 mV", - "label": "630 mV", - "hex": "F09C09" - }, - { - "name": "635 mV", - "label": "635 mV", - "hex": "78B009" - }, - { - "name": "640 mV", - "label": "640 mV", - "hex": "00C409" - }, - { - "name": "645 mV", - "label": "645 mV", - "hex": "88D709" - }, - { - "name": "650 mV", - "label": "650 mV", - "hex": "10EB09" - } -] diff --git a/Ultrahand/OC Toolkit/data/EOS/update.ini b/Ultrahand/OC Toolkit/data/EOS/update.ini deleted file mode 100644 index b8badaa9..00000000 --- a/Ultrahand/OC Toolkit/data/EOS/update.ini +++ /dev/null @@ -1,192 +0,0 @@ -;title='OC Toolkit' -;creator='ppkantorski, B3711' -;about='This package was designed for advance overclock configurations. Use with caution and proper guidance.' - - -[@Software Update] - -[Version] -;mode=table -;background=true -;gap=20 -ini_file './config.ini' -'Latest Version' = '{ini_file(Update,online)}' - -[Update OC Toolkit] -try: -download https://github.com/ppkantorski/Ultrahand-Overlay/releases/latest/download/ovlmenu.ovl /config/ultrahand/downloads/ -move /config/ultrahand/downloads/ovlmenu.ovl /switch/.overlays/ovlmenu.ovl -download https://github.com/halop/OC_Toolkit_SC_EOS/releases/latest/download/OC.Toolkit.zip /config/ultrahand/downloads/ -unzip /config/ultrahand/downloads/OC.Toolkit.zip /config/ultrahand/downloads/OC.Toolkit/ -move './config.ini' '/config/ultrahand/downloads/OC.Toolkit/OC Toolkit/' -delete './' -move '/config/ultrahand/downloads/OC.Toolkit/OC Toolkit/' './' -delete /config/ultrahand/downloads/OC.Toolkit.zip -delete /config/ultrahand/downloads/OC.Toolkit/ - -[gap] -;mode=table -;background=false -;gap=30 - -[Update loader.kip] -try: -download https://github.com/halop/OC_Toolkit_SC_EOS/releases/latest/download/kip.zip /config/ultrahand/downloads/ -set-ini-val './config.ini' Backup Path 'upd' -clear hex_sum_cache -hex_file '/atmosphere/kips/loader.kip' -ini_file './config.ini' -mkdir /atmosphere/kips/.bakTK/ -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuBoost {hex_file(CUST,8,3)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuUVL {hex_file(CUST,12,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuUVH {hex_file(CUST,252,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuVminE {hex_file(CUST,16,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuVmaxE {hex_file(CUST,20,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuVminL {hex_file(CUST,24,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuVminH {hex_file(CUST,28,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuVmaxM {hex_file(CUST,32,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuUVE {hex_file(CUST,36,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuUVM {hex_file(CUST,40,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuOFF {hex_file(CUST,44,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuVminE {hex_file(CUST,48,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuSpeedo {hex_file(CUST,52,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuVminM {hex_file(CUST,56,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuVmax {hex_file(CUST,60,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup DRAM {hex_file(CUST,64,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup ramVDD2 {hex_file(CUST,68,3)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup ramVDDQ {hex_file(CUST,72,3)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup ramMHzE {hex_file(CUST,76,3)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup ramMHzM {hex_file(CUST,80,3)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup DVB {hex_file(CUST,84,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T1 {hex_file(CUST,88,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T2 {hex_file(CUST,92,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T3 {hex_file(CUST,96,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T4 {hex_file(CUST,100,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T5 {hex_file(CUST,104,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T6 {hex_file(CUST,108,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T7 {hex_file(CUST,112,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T8 {hex_file(CUST,116,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 76UV3 {hex_file(CUST,124,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 153UV3 {hex_file(CUST,128,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 230UV3 {hex_file(CUST,132,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 307UV3 {hex_file(CUST,136,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 384UV3 {hex_file(CUST,140,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 460UV3 {hex_file(CUST,144,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 537UV3 {hex_file(CUST,148,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 614UV3 {hex_file(CUST,152,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 691UV3 {hex_file(CUST,156,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 768UV3 {hex_file(CUST,160,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 844UV3 {hex_file(CUST,164,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 921UV3 {hex_file(CUST,168,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 998UV3 {hex_file(CUST,172,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1075UV3 {hex_file(CUST,176,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1152UV3 {hex_file(CUST,180,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1228UV3 {hex_file(CUST,184,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1267UV3 {hex_file(CUST,188,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1305UV3 {hex_file(CUST,192,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1344UV3 {hex_file(CUST,196,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1382UV3 {hex_file(CUST,200,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1420UV3 {hex_file(CUST,204,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1459UV3 {hex_file(CUST,208,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1497UV3 {hex_file(CUST,212,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1536UV3 {hex_file(CUST,216,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1305GPU {hex_file(CUST,256,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup CPUUL {hex_file(CUST,264,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup CPUTABLE {hex_file(CUST,272,2)} -remove-ini-section './config.ini' Backup - -unzip /config/ultrahand/downloads/kip.zip /config/ultrahand/downloads/kip/ -move /atmosphere/kips/loader.kip '/atmosphere/kips/.bakTK/loader.kip.backup' -move /config/ultrahand/downloads/kip/loader.kip '/atmosphere/kips/loader.kip' -delete /config/ultrahand/downloads/kip.zip -delete /config/ultrahand/downloads/kip/ -delete '/atmosphere/kips/loader.kip.backup' - - -set-ini-val './config.ini' Backup Path '/atmosphere/kips/.bakTK/Backup upd.ini' -clear hex_sum_cache -ini_file './config.ini' -ini_file '{ini_file(Backup,Path)}' - -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 8 {ini_file(Backup,cpuBoost)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 12 {ini_file(Backup,cpuUVL)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 252 {ini_file(Backup,cpuUVH)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 16 {ini_file(Backup,cpuVminE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 20 {ini_file(Backup,cpuVmaxE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 24 {ini_file(Backup,cpuVminL)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 28 {ini_file(Backup,cpuVminH)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 32 {ini_file(Backup,cpuVmaxM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 36 {ini_file(Backup,gpuUVE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 40 {ini_file(Backup,gpuUVM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 44 {ini_file(Backup,gpuOFF)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 48 {ini_file(Backup,gpuVminE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 52 {ini_file(Backup,gpuSpeedo)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 56 {ini_file(Backup,gpuVminM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 60 {ini_file(Backup,gpuVmax)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 64 {ini_file(Backup,DRAM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 68 {ini_file(Backup,ramVDD2)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 72 {ini_file(Backup,ramVDDQ)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 76 {ini_file(Backup,ramMHzE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 80 {ini_file(Backup,ramMHzM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 84 {ini_file(Backup,DVB)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 {ini_file(Backup,T1)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 {ini_file(Backup,T2)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 {ini_file(Backup,T3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 {ini_file(Backup,T4)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 {ini_file(Backup,T5)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 {ini_file(Backup,T6)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 {ini_file(Backup,T7)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 {ini_file(Backup,T8)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 124 {ini_file(Backup,76UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 128 {ini_file(Backup,153UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 132 {ini_file(Backup,230UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 136 {ini_file(Backup,307UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 140 {ini_file(Backup,384UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 144 {ini_file(Backup,460UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 148 {ini_file(Backup,537UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 152 {ini_file(Backup,614UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 156 {ini_file(Backup,691UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 160 {ini_file(Backup,768UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 164 {ini_file(Backup,844UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 168 {ini_file(Backup,921UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 172 {ini_file(Backup,998UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 176 {ini_file(Backup,1075UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 180 {ini_file(Backup,1152UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 184 {ini_file(Backup,1228UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 188 {ini_file(Backup,1267UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 192 {ini_file(Backup,1305UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 196 {ini_file(Backup,1344UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 200 {ini_file(Backup,1382UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 204 {ini_file(Backup,1420UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 208 {ini_file(Backup,1459UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 212 {ini_file(Backup,1497UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 216 {ini_file(Backup,1536UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 256 {ini_file(Backup,1305GPU)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 264 {ini_file(Backup,CPUUL)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 272 {ini_file(Backup,CPUTABLE)} -delete '/atmosphere/kips/.bakTK/Backup upd.ini' -exec boot - - -[gap] -;mode=table -;background=false -;gap=30 - - -[Update sys-clk-eos] -try: -download https://github.com/halop/OC_Toolkit_SC_EOS/releases/latest/download/sys-clk.zip /config/ultrahand/downloads/ -unzip /config/ultrahand/downloads/sys-clk.zip /config/ultrahand/downloads/sys-clk/ -move '/config/ultrahand/downloads/sys-clk/' '/' -delete /config/ultrahand/downloads/sys-clk.zip -delete /config/ultrahand/downloads/sys-clk/ - - -[gap] -;mode=table -;background=false -;gap=30 - - -[Package Info] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/data/SC/backup_info.ini b/Ultrahand/OC Toolkit/data/SC/backup_info.ini deleted file mode 100644 index 6b66a25d..00000000 --- a/Ultrahand/OC Toolkit/data/SC/backup_info.ini +++ /dev/null @@ -1,118 +0,0 @@ -;creator=ppkantorski, MestreYodaRossi, B3711 - - -[@Presets] -[RAM] -[RAM Table] -;mode=table -;spacing=4 -;gap=0 -ini_file '/atmosphere/kips/.bakTK/tmp.ini' -'Timings' = {ini_file(Backup,Timings)} -ini_file '/atmosphere/kips/.bakTK/tmp.ini' -json_file './json/dram.json' -'DRAM'= {json_file(0,{ini_file(Backup,DRAM)})} -mariko: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzM)})} -json_file './json/vddq.json' -'Vddq' = {json_file(0,{ini_file(Backup,ramVDDQ)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} -json_file './json/ram_dvb.json' -'EMC DVB' = {json_file(0,{ini_file(Backup,DVB)})} -erista: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{ini_file(Backup,ramMHzE)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{ini_file(Backup,ramVDD2)})} -json_file './json/ram_dvb.json' -'EMC DVB' = {json_file(0,{ini_file(Backup,DVB)})} - - -[CPU] -[CPU Table] -;mode=table -;spacing=4 -;gap=4 -ini_file '/atmosphere/kips/.bakTK/tmp.ini' -json_file './json/numbers.json' -'UV Level' = {json_file(0,{ini_file(Backup,cpuUVL)})} -mariko: -json_file './json/high_freq_uv.json' -'High Freq UV Level' = {json_file(0,{ini_file(Backup,cpuUVH)})} -json_file './json/cpu_table.json' -'Table Config' = {json_file(0,{ini_file(Backup,CPUTABLE)})} -json_file './json/mv.json' -'Low Freq Vmin' = {json_file(0,{ini_file(Backup,cpuVminL)})} -'High Freq Vmin' = {json_file(0,{ini_file(Backup,cpuVminH)})} -json_file './json/voltage_limit.json' -'Volt Limit' = {json_file(0,{ini_file(Backup,cpuVmaxM)})} -json_file './json/max_clocks.json' -'Boost Clock' = {json_file(0,{ini_file(Backup,cpuBoost)})} -json_file './json/cpu_max_clock_m.json' -'Max Clock' = {json_file(0,{ini_file(Backup,CPUUL)})} -erista: -json_file './json/mv.json' -'Vmin' = {json_file(0,{ini_file(Backup,cpuVminE)})} -json_file './json/voltage_limit.json' -'Volt Limit' = {json_file(0,{ini_file(Backup,cpuVmaxE)})} -json_file './json/max_clocks.json' -'Boost Clock' = {json_file(0,{ini_file(Backup,cpuBoost)})} - -[GPU] -[GPU Table] -;mode=table -;spacing=4 -;gap=0 -ini_file '/atmosphere/kips/.bakTK/tmp.ini' -mariko: -json_file './json/gpu_uv_m.json' -'UV Level' = {json_file(0,{ini_file(Backup,gpuUVM)})} -json_file './json/gpu_dvfs_offset_info.json' -'DVFS' = {json_file(0,{ini_file(Backup,gpuDvfsO)})} -json_file './json/vmin.json' -'Vmin' = {json_file(0,{ini_file(Backup,gpuVminM)})} -'Vmax' = {json_file(0,{ini_file(Backup,gpuVmax)})} -json_file './json/voltage_offset.json' -'Volt Offset' = {json_file(0,{ini_file(Backup,gpuOFF)})} -erista: -json_file './json/gpu_uv_e.json' -'UV Level' = {json_file(0,{ini_file(Backup,gpuUVE)})} -json_file './json/mv.json' -'Vmin' = {json_file(0,{ini_file(Backup,gpuVminE)})} -json_file './json/voltage_offset.json' -'Volt Offset' = {json_file(0,{ini_file(Backup,gpuOFF)})} -;gap=100 - -[@Custom Table] -[Custom Table] -[Custom Table] -;mode=table -;spacing=7 -;gap=0 -ini_file '/atmosphere/kips/.bakTK/tmp.ini' -json_file './json/vmin.json' -'76 - 230 MHz' = {json_file(0,{ini_file(Backup,230UV3)})} -'307 MHz' = {json_file(0,{ini_file(Backup,307UV3)})} -'384 MHz' = {json_file(0,{ini_file(Backup,384UV3)})} -'460 MHz' = {json_file(0,{ini_file(Backup,460UV3)})} -'537 MHz' = {json_file(0,{ini_file(Backup,537UV3)})} -'614 MHz' = {json_file(0,{ini_file(Backup,614UV3)})} -'691 MHz' = {json_file(0,{ini_file(Backup,691UV3)})} -'768 MHz' = {json_file(0,{ini_file(Backup,768UV3)})} -'844 MHz' = {json_file(0,{ini_file(Backup,844UV3)})} -'921 MHz' = {json_file(0,{ini_file(Backup,921UV3)})} -'998 MHz' = {json_file(0,{ini_file(Backup,998UV3)})} -'1075 MHz' = {json_file(0,{ini_file(Backup,1075UV3)})} -'1152 MHz' = {json_file(0,{ini_file(Backup,1152UV3)})} -mariko: -'1228 MHz' = {json_file(0,{ini_file(Backup,1228UV3)})} -'1267 MHz' = {json_file(0,{ini_file(Backup,1267UV3)})} -'1305 MHz' = {json_file(0,{ini_file(Backup,1305UV3)})} -'1344 MHz' = {json_file(0,{ini_file(Backup,1344UV3)})} -'1382 MHz' = {json_file(0,{ini_file(Backup,1382UV3)})} -'1420 MHz' = {json_file(0,{ini_file(Backup,1420UV3)})} -'1459 MHz' = {json_file(0,{ini_file(Backup,1459UV3)})} -'1497 MHz' = {json_file(0,{ini_file(Backup,1497UV3)})} -'1536 MHz' = {json_file(0,{ini_file(Backup,1536UV3)})} \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/data/SC/custom_table.ini b/Ultrahand/OC Toolkit/data/SC/custom_table.ini deleted file mode 100644 index d1e61075..00000000 --- a/Ultrahand/OC Toolkit/data/SC/custom_table.ini +++ /dev/null @@ -1,327 +0,0 @@ -;creator='ppkantorski, B3711' - - -[Custom Table] -[*76 - 230 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 124 {json_file_source(*,hex)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 128 {json_file_source(*,hex)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 132 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 124 {json_file_source(*,hex)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 128 {json_file_source(*,hex)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 132 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*307 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 136 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 136 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*384 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 140 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 140 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*460 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 144 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 144 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*537 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 148 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 148 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*614 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 152 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 152 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*691 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 156 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 156 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*768 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 160 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 160 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*844 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 164 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 164 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*921 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 168 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 168 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*998 MHz?GPUUV3] -;mode=option -;mini=true -;selection_mini=true -mariko: -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 172 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 172 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*1075 MHz?GPUUV3mariko] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 176 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*1075 MHz?GPUUV3erista] -;system=erista -;mini=true -;selection_mini=true -;mode=option -json_file_source './erista/gpu_uv3_e.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 176 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*1152 MHz?GPUUV3mariko] -;system=mariko -;mode=option -;mini=true -;selection_mini=true -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 180 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*1152 MHz?GPUUV3erista] -;system=erista -;mini=true -;selection_mini=true -;mode=option -json_file_source './erista/gpu_uv3_e.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 180 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*1228 MHz?GPUUV3] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 184 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*1267 MHz?GPUUV3] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 188 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*1305 MHz?GPUUV3] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 192 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*1344 MHz?GPUUV3] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3_e.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 196 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*1382 MHz?GPUUV3] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3_e.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 200 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*1420 MHz?GPUUV3] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3_e.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 204 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*1459 MHz?GPUUV3] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3_e.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 208 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*1497 MHz?GPUUV3] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3_e.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 212 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*1536 MHz?GPUUV3] -;system=mariko -;mini=true -;selection_mini=true -;mode=option -json_file_source './mariko/gpu_uv3_e.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 216 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[Gap] -;system=mariko -;mode=table -;background=false -;header=false -;gap=20 - - -[*Default Table?GPUUV3] -;mode=forwarder -package_source './default_table.ini' diff --git a/Ultrahand/OC Toolkit/data/SC/erista/gpu_uv3.json b/Ultrahand/OC Toolkit/data/SC/erista/gpu_uv3.json deleted file mode 100644 index e713c7ed..00000000 --- a/Ultrahand/OC Toolkit/data/SC/erista/gpu_uv3.json +++ /dev/null @@ -1,312 +0,0 @@ -[ - { - "name": "Auto", - "hex": "0000", - "label": "Auto" - }, - { - "name": "disabled", - "hex": "D007", - "label": "disabled" - }, - { - "name": "700 mV", - "hex": "BC02", - "label": "700 mV" - }, - { - "name": "705 mV", - "hex": "C102", - "label": "705 mV" - }, - { - "name": "710 mV", - "hex": "C602", - "label": "710 mV" - }, - { - "name": "715 mV", - "hex": "CB02", - "label": "715 mV" - }, - { - "name": "720 mV", - "hex": "D002", - "label": "720 mV" - }, - { - "name": "725 mV", - "hex": "D502", - "label": "725 mV" - }, - { - "name": "730 mV", - "hex": "DA02", - "label": "730 mV" - }, - { - "name": "735 mV", - "hex": "DF02", - "label": "735 mV" - }, - { - "name": "740 mV", - "hex": "E402", - "label": "740 mV" - }, - { - "name": "745 mV", - "hex": "E902", - "label": "745 mV" - }, - { - "name": "750 mV", - "hex": "EE02", - "label": "750 mV" - }, - { - "name": "755 mV", - "hex": "F302", - "label": "755 mV" - }, - { - "name": "760 mV", - "hex": "F802", - "label": "760 mV" - }, - { - "name": "765 mV", - "hex": "FD02", - "label": "765 mV" - }, - { - "name": "770 mV", - "hex": "0203", - "label": "770 mV" - }, - { - "name": "775 mV", - "hex": "0703", - "label": "775 mV" - }, - { - "name": "780 mV", - "hex": "0C03", - "label": "780 mV" - }, - { - "name": "785 mV", - "hex": "1103", - "label": "785 mV" - }, - { - "name": "790 mV", - "hex": "1603", - "label": "790 mV" - }, - { - "name": "795 mV", - "hex": "1B03", - "label": "795 mV" - }, - { - "name": "800 mV", - "hex": "2003", - "label": "800 mV" - }, - { - "name": "805 mV", - "hex": "2503", - "label": "805 mV" - }, - { - "name": "810 mV", - "hex": "2A03", - "label": "810 mV" - }, - { - "name": "815 mV", - "hex": "2F03", - "label": "815 mV" - }, - { - "name": "820 mV", - "hex": "3403", - "label": "820 mV" - }, - { - "name": "825 mV", - "hex": "3903", - "label": "825 mV" - }, - { - "name": "830 mV", - "hex": "3E03", - "label": "830 mV" - }, - { - "name": "835 mV", - "hex": "4303", - "label": "835 mV" - }, - { - "name": "840 mV", - "hex": "4803", - "label": "840 mV" - }, - { - "name": "845 mV", - "hex": "4D03", - "label": "845 mV" - }, - { - "name": "850 mV", - "hex": "5203", - "label": "850 mV" - }, - { - "name": "855 mV", - "hex": "5703", - "label": "855 mV" - }, - { - "name": "860 mV", - "hex": "5C03", - "label": "860 mV" - }, - { - "name": "865 mV", - "hex": "6103", - "label": "865 mV" - }, - { - "name": "870 mV", - "hex": "6603", - "label": "870 mV" - }, - { - "name": "875 mV", - "hex": "6B03", - "label": "875 mV" - }, - { - "name": "880 mV", - "hex": "7003", - "label": "880 mV" - }, - { - "name": "885 mV", - "hex": "7503", - "label": "885 mV" - }, - { - "name": "890 mV", - "hex": "7A03", - "label": "890 mV" - }, - { - "name": "895 mV", - "hex": "7F03", - "label": "895 mV" - }, - { - "name": "900 mV", - "hex": "8403", - "label": "900 mV" - }, - { - "name": "905 mV", - "hex": "8903", - "label": "905 mV" - }, - { - "name": "910 mV", - "hex": "8E03", - "label": "910 mV" - }, - { - "name": "915 mV", - "hex": "9303", - "label": "915 mV" - }, - { - "name": "920 mV", - "hex": "9803", - "label": "920 mV" - }, - { - "name": "925 mV", - "hex": "9D03", - "label": "925 mV" - }, - { - "name": "930 mV", - "hex": "A203", - "label": "930 mV" - }, - { - "name": "935 mV", - "hex": "A703", - "label": "935 mV" - }, - { - "name": "940 mV", - "hex": "AC03", - "label": "940 mV" - }, - { - "name": "945 mV", - "hex": "B103", - "label": "945 mV" - }, - { - "name": "950 mV", - "hex": "B603", - "label": "950 mV" - }, - { - "name": "955 mV", - "hex": "BB03", - "label": "955 mV - unsafe" - }, - { - "name": "960 mV", - "hex": "C003", - "label": "960 mV - unsafe" - }, - { - "name": "965 mV", - "hex": "C503", - "label": "965 mV - unsafe" - }, - { - "name": "970 mV", - "hex": "CA03", - "label": "970 mV - unsafe" - }, - { - "name": "975 mV", - "hex": "CF03", - "label": "975 mV - unsafe" - }, - { - "name": "980 mV", - "hex": "D403", - "label": "980 mV - unsafe" - }, - { - "name": "985 mV", - "hex": "D903", - "label": "985 mV - unsafe" - }, - { - "name": "990 mV", - "hex": "DE03", - "label": "990 mV - unsafe" - }, - { - "name": "995 mV", - "hex": "E303", - "label": "995 mV - unsafe" - } -] diff --git a/Ultrahand/OC Toolkit/data/SC/erista/gpu_uv3_e.json b/Ultrahand/OC Toolkit/data/SC/erista/gpu_uv3_e.json deleted file mode 100644 index 4ba8b1ef..00000000 --- a/Ultrahand/OC Toolkit/data/SC/erista/gpu_uv3_e.json +++ /dev/null @@ -1,307 +0,0 @@ -[ - { - "name": "disabled", - "hex": "D007", - "label": "disabled" - }, - { - "name": "700 mV", - "hex": "BC02", - "label": "700 mV" - }, - { - "name": "705 mV", - "hex": "C102", - "label": "705 mV" - }, - { - "name": "710 mV", - "hex": "C602", - "label": "710 mV" - }, - { - "name": "715 mV", - "hex": "CB02", - "label": "715 mV" - }, - { - "name": "720 mV", - "hex": "D002", - "label": "720 mV" - }, - { - "name": "725 mV", - "hex": "D502", - "label": "725 mV" - }, - { - "name": "730 mV", - "hex": "DA02", - "label": "730 mV" - }, - { - "name": "735 mV", - "hex": "DF02", - "label": "735 mV" - }, - { - "name": "740 mV", - "hex": "E402", - "label": "740 mV" - }, - { - "name": "745 mV", - "hex": "E902", - "label": "745 mV" - }, - { - "name": "750 mV", - "hex": "EE02", - "label": "750 mV" - }, - { - "name": "755 mV", - "hex": "F302", - "label": "755 mV" - }, - { - "name": "760 mV", - "hex": "F802", - "label": "760 mV" - }, - { - "name": "765 mV", - "hex": "FD02", - "label": "765 mV" - }, - { - "name": "770 mV", - "hex": "0203", - "label": "770 mV" - }, - { - "name": "775 mV", - "hex": "0703", - "label": "775 mV" - }, - { - "name": "780 mV", - "hex": "0C03", - "label": "780 mV" - }, - { - "name": "785 mV", - "hex": "1103", - "label": "785 mV" - }, - { - "name": "790 mV", - "hex": "1603", - "label": "790 mV" - }, - { - "name": "795 mV", - "hex": "1B03", - "label": "795 mV" - }, - { - "name": "800 mV", - "hex": "2003", - "label": "800 mV" - }, - { - "name": "805 mV", - "hex": "2503", - "label": "805 mV" - }, - { - "name": "810 mV", - "hex": "2A03", - "label": "810 mV" - }, - { - "name": "815 mV", - "hex": "2F03", - "label": "815 mV" - }, - { - "name": "820 mV", - "hex": "3403", - "label": "820 mV" - }, - { - "name": "825 mV", - "hex": "3903", - "label": "825 mV" - }, - { - "name": "830 mV", - "hex": "3E03", - "label": "830 mV" - }, - { - "name": "835 mV", - "hex": "4303", - "label": "835 mV" - }, - { - "name": "840 mV", - "hex": "4803", - "label": "840 mV" - }, - { - "name": "845 mV", - "hex": "4D03", - "label": "845 mV" - }, - { - "name": "850 mV", - "hex": "5203", - "label": "850 mV" - }, - { - "name": "855 mV", - "hex": "5703", - "label": "855 mV" - }, - { - "name": "860 mV", - "hex": "5C03", - "label": "860 mV" - }, - { - "name": "865 mV", - "hex": "6103", - "label": "865 mV" - }, - { - "name": "870 mV", - "hex": "6603", - "label": "870 mV" - }, - { - "name": "875 mV", - "hex": "6B03", - "label": "875 mV" - }, - { - "name": "880 mV", - "hex": "7003", - "label": "880 mV" - }, - { - "name": "885 mV", - "hex": "7503", - "label": "885 mV" - }, - { - "name": "890 mV", - "hex": "7A03", - "label": "890 mV" - }, - { - "name": "895 mV", - "hex": "7F03", - "label": "895 mV" - }, - { - "name": "900 mV", - "hex": "8403", - "label": "900 mV" - }, - { - "name": "905 mV", - "hex": "8903", - "label": "905 mV" - }, - { - "name": "910 mV", - "hex": "8E03", - "label": "910 mV" - }, - { - "name": "915 mV", - "hex": "9303", - "label": "915 mV" - }, - { - "name": "920 mV", - "hex": "9803", - "label": "920 mV" - }, - { - "name": "925 mV", - "hex": "9D03", - "label": "925 mV" - }, - { - "name": "930 mV", - "hex": "A203", - "label": "930 mV" - }, - { - "name": "935 mV", - "hex": "A703", - "label": "935 mV" - }, - { - "name": "940 mV", - "hex": "AC03", - "label": "940 mV" - }, - { - "name": "945 mV", - "hex": "B103", - "label": "945 mV" - }, - { - "name": "950 mV", - "hex": "B603", - "label": "950 mV" - }, - { - "name": "955 mV", - "hex": "BB03", - "label": "955 mV - unsafe" - }, - { - "name": "960 mV", - "hex": "C003", - "label": "960 mV - unsafe" - }, - { - "name": "965 mV", - "hex": "C503", - "label": "965 mV - unsafe" - }, - { - "name": "970 mV", - "hex": "CA03", - "label": "970 mV - unsafe" - }, - { - "name": "975 mV", - "hex": "CF03", - "label": "975 mV - unsafe" - }, - { - "name": "980 mV", - "hex": "D403", - "label": "980 mV - unsafe" - }, - { - "name": "985 mV", - "hex": "D903", - "label": "985 mV - unsafe" - }, - { - "name": "990 mV", - "hex": "DE03", - "label": "990 mV - unsafe" - }, - { - "name": "995 mV", - "hex": "E303", - "label": "995 mV - unsafe" - } -] diff --git a/Ultrahand/OC Toolkit/data/SC/erista/ram_vdd2.json b/Ultrahand/OC Toolkit/data/SC/erista/ram_vdd2.json deleted file mode 100644 index d795f038..00000000 --- a/Ultrahand/OC Toolkit/data/SC/erista/ram_vdd2.json +++ /dev/null @@ -1,187 +0,0 @@ -[ - { - "name": "Do not override", - "label": "Do not override", - "hex": "000000" - }, - { - "name": "912.5 mV", - "label": "912.5 mV - unsafe", - "hex": "74EC0D" - }, - { - "name": "925 mV", - "label": "925 mV - unsafe", - "hex": "481D0E" - }, - { - "name": "937.5 mV", - "label": "937.5 mV - unsafe", - "hex": "1C4E0E" - }, - { - "name": "950 mV", - "label": "950 mV - unsafe", - "hex": "F07E0E" - }, - { - "name": "962.5 mV", - "label": "962.5 mV - unsafe", - "hex": "C4AF0E" - }, - { - "name": "975 mV", - "label": "975 mV - unsafe", - "hex": "98E00E" - }, - { - "name": "987.5 mV", - "label": "987.5 mV - unsafe", - "hex": "6CZZ0F" - }, - { - "name": "1000 mV", - "label": "1000 mV - unsafe", - "hex": "40420F" - }, - { - "name": "1012.5 mV", - "label": "1012.5 mV - unsafe", - "hex": "14730F" - }, - { - "name": "1025 mV", - "label": "1025 mV - unsafe", - "hex": "E8A30F" - }, - { - "name": "1037.5 mV", - "label": "1037.5 mV - unsafe", - "hex": "BCD40F" - }, - { - "name": "1050 mV", - "label": "1050 mV", - "hex": "900510" - }, - { - "name": "1062.5 mV", - "label": "1062.5 mV", - "hex": "643610" - }, - { - "name": "1075 mV", - "label": "1075 mV", - "hex": "386710" - }, - { - "name": "1087.5 mV", - "label": "1087.5 mV", - "hex": "0C9810" - }, - { - "name": "1100 mV", - "label": "1100 mV", - "hex": "E0C810" - }, - { - "name": "1112.5 mV", - "label": "1112.5 mV", - "hex": "B4F910" - }, - { - "name": "1125 mV", - "label": "1125 mV - default", - "hex": "882A11" - }, - { - "name": "1137.5 mV", - "label": "1137.5 mV", - "hex": "5C5B11" - }, - { - "name": "1150 mV", - "label": "1150 mV", - "hex": "308C11" - }, - { - "name": "1162.5 mV", - "label": "1162.5 mV", - "hex": "04BD11" - }, - { - "name": "1175 mV", - "label": "1175 mV", - "hex": "D8ED11" - }, - { - "name": "1187.5 mV", - "label": "1187.5 mV", - "hex": "AC1E12" - }, - { - "name": "1200 mV", - "label": "1200 mV", - "hex": "804F12" - }, - { - "name": "1212.5 mV", - "label": "1212.5 mV", - "hex": "548012" - }, - { - "name": "1225 mV", - "label": "1225 mV - unsafe", - "hex": "28B112" - }, - { - "name": "1237.5 mV", - "label": "1237.5 mV - unsafe", - "hex": "FCE112" - }, - { - "name": "1250 mV", - "label": "1250 mV - unsafe", - "hex": "D01213" - }, - { - "name": "1262.5 mV", - "label": "1262.5 mV - dangerous", - "hex": "A44313" - }, - { - "name": "1275 mV", - "label": "1275 mV - dangerous", - "hex": "787413" - }, - { - "name": "1287.5 mV", - "label": "1287.5 mV - dangerous", - "hex": "4CA513" - }, - { - "name": "1300 mV", - "label": "1300 mV - dangerous", - "hex": "20D613" - }, - { - "name": "1312.5 mV", - "label": "1312.5 mV - dangerous", - "hex": "F40614" - }, - { - "name": "1325 mV", - "label": "1325 mV - dangerous", - "hex": "C83714" - }, - { - "name": "1337.5 mV", - "label": "1337.5 mV - dangerous", - "hex": "9C6814" - }, - { - "name": "1350 mV", - "label": "1350 mV - dangerous", - "hex": "709914" - } -] diff --git a/Ultrahand/OC Toolkit/data/SC/info.ini b/Ultrahand/OC Toolkit/data/SC/info.ini deleted file mode 100644 index ea28e572..00000000 --- a/Ultrahand/OC Toolkit/data/SC/info.ini +++ /dev/null @@ -1,198 +0,0 @@ -;creator=ppkantorski, MestreYodaRossi, B3711 -;show_version=true - - -[@Presets] -[RAM Table package Info] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -json_file './json/ram_model.json' -'RAM' = '{json_file(0,{ram_model})}' - - -[RAM Table] -;mode=table -;spacing=4 -;gap=0 -hex_file '/atmosphere/kips/loader.kip' -json_file './json/numbers.json' -'Timings' = '({json_file(0,{hex_file(CUST,88,1)})}-{json_file(0,{hex_file(CUST,92,1)})}-{json_file(0,{hex_file(CUST,96,1)})}) {json_file(0,{hex_file(CUST,100,1)})}-{json_file(0,{hex_file(CUST,104,1)})}-{json_file(0,{hex_file(CUST,108,1)})}-{json_file(0,{hex_file(CUST,112,1)})}-{json_file(0,{hex_file(CUST,116,1)})}' - -hex_file '/atmosphere/kips/loader.kip' -json_file './json/dram.json' -'DRAM'= {json_file(0,{hex_file(CUST,64,1)})} -mariko: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{hex_file(CUST,80,3)})} -json_file './json/vddq.json' -'Vddq' = {json_file(0,{hex_file(CUST,72,3)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{hex_file(CUST,68,3)})} -json_file './json/ram_dvb.json' -'EMC DVB' = {json_file(0,{hex_file(CUST,84,1)})} -erista: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{hex_file(CUST,76,3)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{hex_file(CUST,68,3)})} -json_file './json/ram_dvb.json' -'EMC DVB' = {json_file(0,{hex_file(CUST,84,1)})} - -[gap] -;mode=table -;background=false -;gap=25 - -[CPU Table package Info] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -'CPU' = '{cpu_speedo}' - -[CPU Table] -;mode=table -;spacing=4 -;gap=0 -hex_file '/atmosphere/kips/loader.kip' -json_file './json/numbers.json' -'UV Level' = {json_file(0,{hex_file(CUST,12,1)})} -mariko: -json_file './json/high_freq_uv.json' -'High Freq UV Level' = {json_file(0,{hex_file(CUST,252,1)})} -json_file './json/cpu_table.json' -'Table Config' = {json_file(0,{hex_file(CUST,272,1)})} -json_file './json/mv.json' -'Low Freq Vmin' = {json_file(0,{hex_file(CUST,24,2)})} -'High Freq Vmin' = {json_file(0,{hex_file(CUST,28,2)})} -json_file './json/voltage_limit.json' -'Volt Limit' = {json_file(0,{hex_file(CUST,32,2)})} -json_file './json/max_clocks.json' -'Boost Clock' = {json_file(0,{hex_file(CUST,8,3)})} -json_file './json/cpu_max_clock_m.json' -'Max Clock' = {json_file(0,{hex_file(CUST,264,1)})} -erista: -json_file './json/mv.json' -'Vmin' = {json_file(0,{hex_file(CUST,16,2)})} -json_file './json/voltage_limit.json' -'Volt Limit' = {json_file(0,{hex_file(CUST,20,2)})} -json_file './json/max_clocks.json' -'Boost Clock' = {json_file(0,{hex_file(CUST,8,3)})} - -[gap] -;mode=table -;background=false -;gap=25 - -[GPU Table package Info] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -'GPU' = '{gpu_speedo}' - -[GPU Table] -;mode=table -;spacing=4 -;gap=0 -hex_file '/atmosphere/kips/loader.kip' -mariko: -json_file './json/gpu_uv_m.json' -'UV Level' = {json_file(0,{hex_file(CUST,40,1)})} -ini_file '/config/sys-clk/config.ini' -json_file './json/gpu_dvfs_offset_info.json' -'DVFS' = {json_file(0,{ini_file(values,gpu_dvfs_offset)})} -json_file './json/vmin.json' -'Vmin' = {json_file(0,{hex_file(CUST,56,2)})} -'Vmax' = {json_file(0,{hex_file(CUST,60,2)})} -json_file './json/voltage_offset.json' -'Volt Offset' = {json_file(0,{hex_file(CUST,44,1)})} -erista: -json_file './json/gpu_uv_e.json' -'UV Level' = {json_file(0,{hex_file(CUST,36,1)})} -json_file './json/mv.json' -'Vmin' = {json_file(0,{hex_file(CUST,48,2)})} -json_file './json/voltage_offset.json' -'Volt Offset' = {json_file(0,{hex_file(CUST,44,1)})} -;gap=100 - -[@Custom Table] -[Custom Table] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -hex_file '/atmosphere/kips/loader.kip' -json_file './json/version.json' -'Custom Table' = '{json_file(0,{hex_file(CUST,260,1)})} kip' - -[Custom Table] -;mode=table -;spacing=5 -;gap=35 -hex_file '/atmosphere/kips/loader.kip' -json_file './json/vmin.json' -'76 - 230 MHz' = {json_file(0,{hex_file(CUST,132,2)})} -'307 MHz' = {json_file(0,{hex_file(CUST,136,2)})} -'384 MHz' = {json_file(0,{hex_file(CUST,140,2)})} -'460 MHz' = {json_file(0,{hex_file(CUST,144,2)})} -'537 MHz' = {json_file(0,{hex_file(CUST,148,2)})} -'614 MHz' = {json_file(0,{hex_file(CUST,152,2)})} -'691 MHz' = {json_file(0,{hex_file(CUST,156,2)})} -'768 MHz' = {json_file(0,{hex_file(CUST,160,2)})} -'844 MHz' = {json_file(0,{hex_file(CUST,164,2)})} -'921 MHz' = {json_file(0,{hex_file(CUST,168,2)})} -'998 MHz' = {json_file(0,{hex_file(CUST,172,2)})} -'1075 MHz' = {json_file(0,{hex_file(CUST,176,2)})} -'1152 MHz' = {json_file(0,{hex_file(CUST,180,2)})} -mariko: -'1228 MHz' = {json_file(0,{hex_file(CUST,184,2)})} -'1267 MHz' = {json_file(0,{hex_file(CUST,188,2)})} -'1305 MHz' = {json_file(0,{hex_file(CUST,192,2)})} -'1344 MHz' = {json_file(0,{hex_file(CUST,196,2)})} -'1382 MHz' = {json_file(0,{hex_file(CUST,200,2)})} -'1420 MHz' = {json_file(0,{hex_file(CUST,204,2)})} -'1459 MHz' = {json_file(0,{hex_file(CUST,208,2)})} -'1497 MHz' = {json_file(0,{hex_file(CUST,212,2)})} -'1536 MHz' = {json_file(0,{hex_file(CUST,216,2)})} - -[Speedos1] -;mode=table -;background=false -;spacing=4 -;gap=15 -;header_indent=true -;info_text_color=header -;section_text_color=header -'Device Info' = ' CPU GPU SOC' - -[Speedos2] -;mode=table -;spacing=4 -;gap=25 -'Speedo' = '{cpu_speedo} | {gpu_speedo} | {soc_speedo}' -mariko: -'IDDQ' = ' {cpu_iddq} | {gpu_iddq} | {soc_iddq}' -erista: -'IDDQ' = ' {cpu_iddq} | {gpu_iddq} | {soc_iddq}' - -[Device Info Table] -;mode=table -;spacing=4 -;gap=15 -'Firmware' = 'HOS {hos_version} | AMS {ams_version}' -'RAM' = '{ram_model}' \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/data/SC/mariko/cpu_voltages.json b/Ultrahand/OC Toolkit/data/SC/mariko/cpu_voltages.json deleted file mode 100644 index 99d9c401..00000000 --- a/Ultrahand/OC Toolkit/data/SC/mariko/cpu_voltages.json +++ /dev/null @@ -1,182 +0,0 @@ -[ - { - "name": "900 mV", - "label": "900 mV", - "hex": "8403" - }, - { - "name": "925 mV", - "label": "925 mV", - "hex": "9D03" - }, - { - "name": "950 mV", - "label": "950 mV", - "hex": "B603" - }, - { - "name": "975 mV", - "label": "975 mV", - "hex": "CF03" - }, - { - "name": "1000 mV", - "label": "1000 mV", - "hex": "E803" - }, - { - "name": "1025 mV", - "label": "1025 mV", - "hex": "0104" - }, - { - "name": "1050 mV", - "label": "1050 mV", - "hex": "1A04" - }, - { - "name": "1075 mV", - "label": "1075 mV", - "hex": "3304" - }, - { - "name": "1100 mV", - "label": "1100 mV", - "hex": "4C04" - }, - { - "name": "1105 mV", - "label": "1105 mV", - "hex": "5104" - }, - { - "name": "1110 mV", - "label": "1110 mV", - "hex": "5604" - }, - { - "name": "1115 mV", - "label": "1115 mV", - "hex": "5B04" - }, - { - "name": "1120 mV", - "label": "1120 mV - default", - "hex": "6004" - }, - { - "name": "1125 mV", - "label": "1125 mV", - "hex": "6504" - }, - { - "name": "1130 mV", - "label": "1130 mV", - "hex": "6A04" - }, - { - "name": "1135 mV", - "label": "1135 mV", - "hex": "6F04" - }, - { - "name": "1140 mV", - "label": "1140 mV", - "hex": "7404" - }, - { - "name": "1145 mV", - "label": "1145 mV", - "hex": "7904" - }, - { - "name": "1150 mV", - "label": "1150 mV", - "hex": "7E04" - }, - { - "name": "1155 mV", - "label": "1155 mV", - "hex": "8304" - }, - { - "name": "1160 mV", - "label": "1160 mV", - "hex": "8804" - }, - { - "name": "1165 mV", - "label": "1165 mV - dangerous", - "hex": "8D04" - }, - { - "name": "1170 mV", - "label": "1170 mV - dangerous", - "hex": "9204" - }, - { - "name": "1175 mV", - "label": "1175 mV - dangerous", - "hex": "9704" - }, - { - "name": "1180 mV", - "label": "1180 mV - dangerous", - "hex": "9C04" - }, - { - "name": "1185 mV", - "label": "1185 mV - dangerous", - "hex": "A104" - }, - { - "name": "1190 mV", - "label": "1190 mV - dangerous", - "hex": "A604" - }, - { - "name": "1195 mV", - "label": "1195 mV - dangerous", - "hex": "AB04" - }, - { - "name": "1200 mV", - "label": "1200 mV - dangerous", - "hex": "B004" - }, - { - "name": "1205 mV", - "label": "1205 mV - dangerous", - "hex": "B504" - }, - { - "name": "1210 mV", - "label": "1210 mV - dangerous", - "hex": "BA04" - }, - { - "name": "1215 mV", - "label": "1215 mV - dangerous", - "hex": "BF04" - }, - { - "name": "1220 mV", - "label": "1220 mV - dangerous", - "hex": "C404" - }, - { - "name": "1225 mV", - "label": "1225 mV - dangerous", - "hex": "C904" - }, - { - "name": "1230 mV", - "label": "1230 mV - dangerous", - "hex": "CE04" - }, - { - "name": "1235 mV", - "label": "1235 mV - dangerous", - "hex": "D304" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/data/SC/mariko/gpu_uv3.json b/Ultrahand/OC Toolkit/data/SC/mariko/gpu_uv3.json deleted file mode 100644 index 5ee6cccb..00000000 --- a/Ultrahand/OC Toolkit/data/SC/mariko/gpu_uv3.json +++ /dev/null @@ -1,497 +0,0 @@ -[ - { - "name": "Auto", - "hex": "0000", - "label": "Auto" - }, - { - "name": "disabled", - "hex": "D007", - "label": "disabled" - }, - { - "name": "480 mV", - "hex": "E001", - "label": "480 mV" - }, - { - "name": "485 mV", - "hex": "E501", - "label": "485 mV" - }, - { - "name": "490 mV", - "hex": "EA01", - "label": "490 mV" - }, - { - "name": "495 mV", - "hex": "EF01", - "label": "495 mV" - }, - { - "name": "500 mV", - "hex": "F401", - "label": "500 mV" - }, - { - "name": "505 mV", - "hex": "F901", - "label": "505 mV" - }, - { - "name": "510 mV", - "hex": "FE01", - "label": "510 mV" - }, - { - "name": "515 mV", - "hex": "0302", - "label": "515 mV" - }, - { - "name": "520 mV", - "hex": "0802", - "label": "520 mV" - }, - { - "name": "525 mV", - "hex": "0D02", - "label": "525 mV" - }, - { - "name": "530 mV", - "hex": "1202", - "label": "530 mV" - }, - { - "name": "535 mV", - "hex": "1702", - "label": "535 mV" - }, - { - "name": "540 mV", - "hex": "1C02", - "label": "540 mV" - }, - { - "name": "545 mV", - "hex": "2102", - "label": "545 mV" - }, - { - "name": "550 mV", - "hex": "2602", - "label": "550 mV" - }, - { - "name": "555 mV", - "hex": "2B02", - "label": "555 mV" - }, - { - "name": "560 mV", - "hex": "3002", - "label": "560 mV" - }, - { - "name": "565 mV", - "hex": "3502", - "label": "565 mV" - }, - { - "name": "570 mV", - "hex": "3A02", - "label": "570 mV" - }, - { - "name": "575 mV", - "hex": "3F02", - "label": "575 mV" - }, - { - "name": "580 mV", - "hex": "4402", - "label": "580 mV" - }, - { - "name": "585 mV", - "hex": "4902", - "label": "585 mV" - }, - { - "name": "590 mV", - "hex": "4E02", - "label": "590 mV" - }, - { - "name": "595 mV", - "hex": "5302", - "label": "595 mV" - }, - { - "name": "600 mV", - "hex": "5802", - "label": "600 mV" - }, - { - "name": "605 mV", - "hex": "5D02", - "label": "605 mV" - }, - { - "name": "610 mV", - "hex": "6202", - "label": "610 mV" - }, - { - "name": "615 mV", - "hex": "6702", - "label": "615 mV" - }, - { - "name": "620 mV", - "hex": "6C02", - "label": "620 mV" - }, - { - "name": "625 mV", - "hex": "7102", - "label": "625 mV" - }, - { - "name": "630 mV", - "hex": "7602", - "label": "630 mV" - }, - { - "name": "635 mV", - "hex": "7B02", - "label": "635 mV" - }, - { - "name": "640 mV", - "hex": "8002", - "label": "640 mV" - }, - { - "name": "645 mV", - "hex": "8502", - "label": "645 mV" - }, - { - "name": "650 mV", - "hex": "8A02", - "label": "650 mV" - }, - { - "name": "655 mV", - "hex": "8F02", - "label": "655 mV" - }, - { - "name": "660 mV", - "hex": "9402", - "label": "660 mV" - }, - { - "name": "665 mV", - "hex": "9902", - "label": "665 mV" - }, - { - "name": "670 mV", - "hex": "9E02", - "label": "670 mV" - }, - { - "name": "675 mV", - "hex": "A302", - "label": "675 mV" - }, - { - "name": "680 mV", - "hex": "A802", - "label": "680 mV" - }, - { - "name": "685 mV", - "hex": "AD02", - "label": "685 mV" - }, - { - "name": "690 mV", - "hex": "B202", - "label": "690 mV" - }, - { - "name": "695 mV", - "hex": "B702", - "label": "695 mV" - }, - { - "name": "700 mV", - "hex": "BC02", - "label": "700 mV" - }, - { - "name": "705 mV", - "hex": "C102", - "label": "705 mV" - }, - { - "name": "710 mV", - "hex": "C602", - "label": "710 mV" - }, - { - "name": "715 mV", - "hex": "CB02", - "label": "715 mV" - }, - { - "name": "720 mV", - "hex": "D002", - "label": "720 mV" - }, - { - "name": "725 mV", - "hex": "D502", - "label": "725 mV" - }, - { - "name": "730 mV", - "hex": "DA02", - "label": "730 mV" - }, - { - "name": "735 mV", - "hex": "DF02", - "label": "735 mV" - }, - { - "name": "740 mV", - "hex": "E402", - "label": "740 mV" - }, - { - "name": "745 mV", - "hex": "E902", - "label": "745 mV" - }, - { - "name": "750 mV", - "hex": "EE02", - "label": "750 mV" - }, - { - "name": "755 mV", - "hex": "F302", - "label": "755 mV" - }, - { - "name": "760 mV", - "hex": "F802", - "label": "760 mV" - }, - { - "name": "765 mV", - "hex": "FD02", - "label": "765 mV" - }, - { - "name": "770 mV", - "hex": "0203", - "label": "770 mV" - }, - { - "name": "775 mV", - "hex": "0703", - "label": "775 mV" - }, - { - "name": "780 mV", - "hex": "0C03", - "label": "780 mV" - }, - { - "name": "785 mV", - "hex": "1103", - "label": "785 mV" - }, - { - "name": "790 mV", - "hex": "1603", - "label": "790 mV" - }, - { - "name": "795 mV", - "hex": "1B03", - "label": "795 mV" - }, - { - "name": "800 mV", - "hex": "2003", - "label": "800 mV - unsafe" - }, - { - "name": "805 mV", - "hex": "2503", - "label": "805 mV - unsafe" - }, - { - "name": "810 mV", - "hex": "2A03", - "label": "810 mV - unsafe" - }, - { - "name": "815 mV", - "hex": "2F03", - "label": "815 mV - unsafe" - }, - { - "name": "820 mV", - "hex": "3403", - "label": "820 mV - unsafe" - }, - { - "name": "825 mV", - "hex": "3903", - "label": "825 mV - unsafe" - }, - { - "name": "830 mV", - "hex": "3E03", - "label": "830 mV - unsafe" - }, - { - "name": "835 mV", - "hex": "4303", - "label": "835 mV - unsafe" - }, - { - "name": "840 mV", - "hex": "4803", - "label": "840 mV - unsafe" - }, - { - "name": "845 mV", - "hex": "4D03", - "label": "845 mV - unsafe" - }, - { - "name": "850 mV", - "hex": "5203", - "label": "850 mV - unsafe" - }, - { - "name": "855 mV", - "hex": "5703", - "label": "855 mV - dangerous" - }, - { - "name": "860 mV", - "hex": "5C03", - "label": "860 mV - dangerous" - }, - { - "name": "865 mV", - "hex": "6103", - "label": "865 mV - dangerous" - }, - { - "name": "870 mV", - "hex": "6603", - "label": "870 mV - dangerous" - }, - { - "name": "875 mV", - "hex": "6B03", - "label": "875 mV - dangerous" - }, - { - "name": "880 mV", - "hex": "7003", - "label": "880 mV - dangerous" - }, - { - "name": "885 mV", - "hex": "7503", - "label": "885 mV - dangerous" - }, - { - "name": "890 mV", - "hex": "7A03", - "label": "890 mV - dangerous" - }, - { - "name": "895 mV", - "hex": "7F03", - "label": "895 mV - dangerous" - }, - { - "name": "900 mV", - "hex": "8403", - "label": "900 mV - dangerous" - }, - { - "name": "905 mV", - "hex": "8903", - "label": "905 mV - dangerous" - }, - { - "name": "910 mV", - "hex": "8E03", - "label": "910 mV - dangerous" - }, - { - "name": "915 mV", - "hex": "9303", - "label": "915 mV - dangerous" - }, - { - "name": "920 mV", - "hex": "9803", - "label": "920 mV - dangerous" - }, - { - "name": "925 mV", - "hex": "9D03", - "label": "925 mV - dangerous" - }, - { - "name": "930 mV", - "hex": "A203", - "label": "930 mV - dangerous" - }, - { - "name": "935 mV", - "hex": "A703", - "label": "935 mV - dangerous" - }, - { - "name": "940 mV", - "hex": "AC03", - "label": "940 mV - dangerous" - }, - { - "name": "945 mV", - "hex": "B103", - "label": "945 mV - dangerous" - }, - { - "name": "950 mV", - "hex": "B603", - "label": "950 mV - dangerous" - }, - { - "name": "955 mV", - "hex": "BB03", - "label": "955 mV - dangerous" - }, - { - "name": "960 mV", - "hex": "C003", - "label": "960 mV - dangerous" - } -] diff --git a/Ultrahand/OC Toolkit/data/SC/mariko/gpu_uv3_e.json b/Ultrahand/OC Toolkit/data/SC/mariko/gpu_uv3_e.json deleted file mode 100644 index 85f1f2f5..00000000 --- a/Ultrahand/OC Toolkit/data/SC/mariko/gpu_uv3_e.json +++ /dev/null @@ -1,492 +0,0 @@ -[ - { - "name": "disabled", - "hex": "D007", - "label": "disabled" - }, - { - "name": "480 mV", - "hex": "E001", - "label": "480 mV" - }, - { - "name": "485 mV", - "hex": "E501", - "label": "485 mV" - }, - { - "name": "490 mV", - "hex": "EA01", - "label": "490 mV" - }, - { - "name": "495 mV", - "hex": "EF01", - "label": "495 mV" - }, - { - "name": "500 mV", - "hex": "F401", - "label": "500 mV" - }, - { - "name": "505 mV", - "hex": "F901", - "label": "505 mV" - }, - { - "name": "510 mV", - "hex": "FE01", - "label": "510 mV" - }, - { - "name": "515 mV", - "hex": "0302", - "label": "515 mV" - }, - { - "name": "520 mV", - "hex": "0802", - "label": "520 mV" - }, - { - "name": "525 mV", - "hex": "0D02", - "label": "525 mV" - }, - { - "name": "530 mV", - "hex": "1202", - "label": "530 mV" - }, - { - "name": "535 mV", - "hex": "1702", - "label": "535 mV" - }, - { - "name": "540 mV", - "hex": "1C02", - "label": "540 mV" - }, - { - "name": "545 mV", - "hex": "2102", - "label": "545 mV" - }, - { - "name": "550 mV", - "hex": "2602", - "label": "550 mV" - }, - { - "name": "555 mV", - "hex": "2B02", - "label": "555 mV" - }, - { - "name": "560 mV", - "hex": "3002", - "label": "560 mV" - }, - { - "name": "565 mV", - "hex": "3502", - "label": "565 mV" - }, - { - "name": "570 mV", - "hex": "3A02", - "label": "570 mV" - }, - { - "name": "575 mV", - "hex": "3F02", - "label": "575 mV" - }, - { - "name": "580 mV", - "hex": "4402", - "label": "580 mV" - }, - { - "name": "585 mV", - "hex": "4902", - "label": "585 mV" - }, - { - "name": "590 mV", - "hex": "4E02", - "label": "590 mV" - }, - { - "name": "595 mV", - "hex": "5302", - "label": "595 mV" - }, - { - "name": "600 mV", - "hex": "5802", - "label": "600 mV" - }, - { - "name": "605 mV", - "hex": "5D02", - "label": "605 mV" - }, - { - "name": "610 mV", - "hex": "6202", - "label": "610 mV" - }, - { - "name": "615 mV", - "hex": "6702", - "label": "615 mV" - }, - { - "name": "620 mV", - "hex": "6C02", - "label": "620 mV" - }, - { - "name": "625 mV", - "hex": "7102", - "label": "625 mV" - }, - { - "name": "630 mV", - "hex": "7602", - "label": "630 mV" - }, - { - "name": "635 mV", - "hex": "7B02", - "label": "635 mV" - }, - { - "name": "640 mV", - "hex": "8002", - "label": "640 mV" - }, - { - "name": "645 mV", - "hex": "8502", - "label": "645 mV" - }, - { - "name": "650 mV", - "hex": "8A02", - "label": "650 mV" - }, - { - "name": "655 mV", - "hex": "8F02", - "label": "655 mV" - }, - { - "name": "660 mV", - "hex": "9402", - "label": "660 mV" - }, - { - "name": "665 mV", - "hex": "9902", - "label": "665 mV" - }, - { - "name": "670 mV", - "hex": "9E02", - "label": "670 mV" - }, - { - "name": "675 mV", - "hex": "A302", - "label": "675 mV" - }, - { - "name": "680 mV", - "hex": "A802", - "label": "680 mV" - }, - { - "name": "685 mV", - "hex": "AD02", - "label": "685 mV" - }, - { - "name": "690 mV", - "hex": "B202", - "label": "690 mV" - }, - { - "name": "695 mV", - "hex": "B702", - "label": "695 mV" - }, - { - "name": "700 mV", - "hex": "BC02", - "label": "700 mV" - }, - { - "name": "705 mV", - "hex": "C102", - "label": "705 mV" - }, - { - "name": "710 mV", - "hex": "C602", - "label": "710 mV" - }, - { - "name": "715 mV", - "hex": "CB02", - "label": "715 mV" - }, - { - "name": "720 mV", - "hex": "D002", - "label": "720 mV" - }, - { - "name": "725 mV", - "hex": "D502", - "label": "725 mV" - }, - { - "name": "730 mV", - "hex": "DA02", - "label": "730 mV" - }, - { - "name": "735 mV", - "hex": "DF02", - "label": "735 mV" - }, - { - "name": "740 mV", - "hex": "E402", - "label": "740 mV" - }, - { - "name": "745 mV", - "hex": "E902", - "label": "745 mV" - }, - { - "name": "750 mV", - "hex": "EE02", - "label": "750 mV" - }, - { - "name": "755 mV", - "hex": "F302", - "label": "755 mV" - }, - { - "name": "760 mV", - "hex": "F802", - "label": "760 mV" - }, - { - "name": "765 mV", - "hex": "FD02", - "label": "765 mV" - }, - { - "name": "770 mV", - "hex": "0203", - "label": "770 mV" - }, - { - "name": "775 mV", - "hex": "0703", - "label": "775 mV" - }, - { - "name": "780 mV", - "hex": "0C03", - "label": "780 mV" - }, - { - "name": "785 mV", - "hex": "1103", - "label": "785 mV" - }, - { - "name": "790 mV", - "hex": "1603", - "label": "790 mV" - }, - { - "name": "795 mV", - "hex": "1B03", - "label": "795 mV" - }, - { - "name": "800 mV", - "hex": "2003", - "label": "800 mV - unsafe" - }, - { - "name": "805 mV", - "hex": "2503", - "label": "805 mV - unsafe" - }, - { - "name": "810 mV", - "hex": "2A03", - "label": "810 mV - unsafe" - }, - { - "name": "815 mV", - "hex": "2F03", - "label": "815 mV - unsafe" - }, - { - "name": "820 mV", - "hex": "3403", - "label": "820 mV - unsafe" - }, - { - "name": "825 mV", - "hex": "3903", - "label": "825 mV - unsafe" - }, - { - "name": "830 mV", - "hex": "3E03", - "label": "830 mV - unsafe" - }, - { - "name": "835 mV", - "hex": "4303", - "label": "835 mV - unsafe" - }, - { - "name": "840 mV", - "hex": "4803", - "label": "840 mV - unsafe" - }, - { - "name": "845 mV", - "hex": "4D03", - "label": "845 mV - unsafe" - }, - { - "name": "850 mV", - "hex": "5203", - "label": "850 mV - unsafe" - }, - { - "name": "855 mV", - "hex": "5703", - "label": "855 mV - dangerous" - }, - { - "name": "860 mV", - "hex": "5C03", - "label": "860 mV - dangerous" - }, - { - "name": "865 mV", - "hex": "6103", - "label": "865 mV - dangerous" - }, - { - "name": "870 mV", - "hex": "6603", - "label": "870 mV - dangerous" - }, - { - "name": "875 mV", - "hex": "6B03", - "label": "875 mV - dangerous" - }, - { - "name": "880 mV", - "hex": "7003", - "label": "880 mV - dangerous" - }, - { - "name": "885 mV", - "hex": "7503", - "label": "885 mV - dangerous" - }, - { - "name": "890 mV", - "hex": "7A03", - "label": "890 mV - dangerous" - }, - { - "name": "895 mV", - "hex": "7F03", - "label": "895 mV - dangerous" - }, - { - "name": "900 mV", - "hex": "8403", - "label": "900 mV - dangerous" - }, - { - "name": "905 mV", - "hex": "8903", - "label": "905 mV - dangerous" - }, - { - "name": "910 mV", - "hex": "8E03", - "label": "910 mV - dangerous" - }, - { - "name": "915 mV", - "hex": "9303", - "label": "915 mV - dangerous" - }, - { - "name": "920 mV", - "hex": "9803", - "label": "920 mV - dangerous" - }, - { - "name": "925 mV", - "hex": "9D03", - "label": "925 mV - dangerous" - }, - { - "name": "930 mV", - "hex": "A203", - "label": "930 mV - dangerous" - }, - { - "name": "935 mV", - "hex": "A703", - "label": "935 mV - dangerous" - }, - { - "name": "940 mV", - "hex": "AC03", - "label": "940 mV - dangerous" - }, - { - "name": "945 mV", - "hex": "B103", - "label": "945 mV - dangerous" - }, - { - "name": "950 mV", - "hex": "B603", - "label": "950 mV - dangerous" - }, - { - "name": "955 mV", - "hex": "BB03", - "label": "955 mV - dangerous" - }, - { - "name": "960 mV", - "hex": "C003", - "label": "960 mV - dangerous" - } -] diff --git a/Ultrahand/OC Toolkit/data/SC/mariko/gpu_vmax.json b/Ultrahand/OC Toolkit/data/SC/mariko/gpu_vmax.json deleted file mode 100644 index 0d243935..00000000 --- a/Ultrahand/OC Toolkit/data/SC/mariko/gpu_vmax.json +++ /dev/null @@ -1,134 +0,0 @@ -[ - { - "name": "800 mV", - "hex": "2003" - }, - { - "name": "805 mV", - "hex": "2503" - }, - { - "name": "810 mV", - "hex": "2A03" - }, - { - "name": "815 mV", - "hex": "2F03" - }, - { - "name": "820 mV", - "hex": "3403" - }, - { - "name": "825 mV", - "hex": "3903" - }, - { - "name": "830 mV", - "hex": "3E03" - }, - { - "name": "835 mV", - "hex": "4303" - }, - { - "name": "840 mV", - "hex": "4803" - }, - { - "name": "845 mV", - "hex": "4D03" - }, - { - "name": "850 mV", - "hex": "5203" - }, - { - "name": "855 mV", - "hex": "5703" - }, - { - "name": "860 mV", - "hex": "5C03" - }, - { - "name": "865 mV", - "hex": "6103" - }, - { - "name": "870 mV", - "hex": "6603" - }, - { - "name": "875 mV", - "hex": "6B03" - }, - { - "name": "880 mV", - "hex": "7003" - }, - { - "name": "885 mV", - "hex": "7503" - }, - { - "name": "890 mV", - "hex": "7A03" - }, - { - "name": "895 mV", - "hex": "7F03" - }, - { - "name": "900 mV", - "hex": "8403" - }, - { - "name": "905 mV", - "hex": "8903" - }, - { - "name": "910 mV", - "hex": "8E03" - }, - { - "name": "915 mV", - "hex": "9303" - }, - { - "name": "920 mV", - "hex": "9803" - }, - { - "name": "925 mV", - "hex": "9D03" - }, - { - "name": "930 mV", - "hex": "A203" - }, - { - "name": "935 mV", - "hex": "A703" - }, - { - "name": "940 mV", - "hex": "AC03" - }, - { - "name": "945 mV", - "hex": "B103" - }, - { - "name": "950 mV", - "hex": "B603" - }, - { - "name": "955 mV", - "hex": "BB03" - }, - { - "name": "960 mV", - "hex": "C003" - } -] diff --git a/Ultrahand/OC Toolkit/data/SC/mariko/ram_vdd2.json b/Ultrahand/OC Toolkit/data/SC/mariko/ram_vdd2.json deleted file mode 100644 index 9dc6f83b..00000000 --- a/Ultrahand/OC Toolkit/data/SC/mariko/ram_vdd2.json +++ /dev/null @@ -1,187 +0,0 @@ -[ - { - "name": "Do not override", - "label": "Do not override", - "hex": "000000" - }, - { - "name": "912.5 mV", - "label": "912.5 mV - unsafe", - "hex": "74EC0D" - }, - { - "name": "925 mV", - "label": "925 mV - unsafe", - "hex": "481D0E" - }, - { - "name": "937.5 mV", - "label": "937.5 mV - unsafe", - "hex": "1C4E0E" - }, - { - "name": "950 mV", - "label": "950 mV - unsafe", - "hex": "F07E0E" - }, - { - "name": "962.5 mV", - "label": "962.5 mV - unsafe", - "hex": "C4AF0E" - }, - { - "name": "975 mV", - "label": "975 mV - unsafe", - "hex": "98E00E" - }, - { - "name": "987.5 mV", - "label": "987.5 mV - unsafe", - "hex": "6CZZ0F" - }, - { - "name": "1000 mV", - "label": "1000 mV - unsafe", - "hex": "40420F" - }, - { - "name": "1012.5 mV", - "label": "1012.5 mV - unsafe", - "hex": "14730F" - }, - { - "name": "1025 mV", - "label": "1025 mV - unsafe", - "hex": "E8A30F" - }, - { - "name": "1037.5 mV", - "label": "1037.5 mV - unsafe", - "hex": "BCD40F" - }, - { - "name": "1050 mV", - "label": "1050 mV", - "hex": "900510" - }, - { - "name": "1062.5 mV", - "label": "1062.5 mV", - "hex": "643610" - }, - { - "name": "1075 mV", - "label": "1075 mV", - "hex": "386710" - }, - { - "name": "1087.5 mV", - "label": "1087.5 mV", - "hex": "0C9810" - }, - { - "name": "1100 mV", - "label": "1100 mV - default", - "hex": "E0C810" - }, - { - "name": "1112.5 mV", - "label": "1112.5 mV", - "hex": "B4F910" - }, - { - "name": "1125 mV", - "label": "1125 mV", - "hex": "882A11" - }, - { - "name": "1137.5 mV", - "label": "1137.5 mV", - "hex": "5C5B11" - }, - { - "name": "1150 mV", - "label": "1150 mV", - "hex": "308C11" - }, - { - "name": "1162.5 mV", - "label": "1162.5 mV", - "hex": "04BD11" - }, - { - "name": "1175 mV", - "label": "1175 mV", - "hex": "D8ED11" - }, - { - "name": "1187.5 mV", - "label": "1187.5 mV", - "hex": "AC1E12" - }, - { - "name": "1200 mV", - "label": "1200 mV", - "hex": "804F12" - }, - { - "name": "1212.5 mV", - "label": "1212.5 mV", - "hex": "548012" - }, - { - "name": "1225 mV", - "label": "1225 mV - unsafe", - "hex": "28B112" - }, - { - "name": "1237.5 mV", - "label": "1237.5 mV - unsafe", - "hex": "FCE112" - }, - { - "name": "1250 mV", - "label": "1250 mV - unsafe", - "hex": "D01213" - }, - { - "name": "1262.5 mV", - "label": "1262.5 mV - dangerous", - "hex": "A44313" - }, - { - "name": "1275 mV", - "label": "1275 mV - dangerous", - "hex": "787413" - }, - { - "name": "1287.5 mV", - "label": "1287.5 mV - dangerous", - "hex": "4CA513" - }, - { - "name": "1300 mV", - "label": "1300 mV - dangerous", - "hex": "20D613" - }, - { - "name": "1312.5 mV", - "label": "1312.5 mV - dangerous", - "hex": "F40614" - }, - { - "name": "1325 mV", - "label": "1325 mV - dangerous", - "hex": "C83714" - }, - { - "name": "1337.5 mV", - "label": "1337.5 mV - dangerous", - "hex": "9C6814" - }, - { - "name": "1350 mV", - "label": "1350 mV - dangerous", - "hex": "709914" - } -] diff --git a/Ultrahand/OC Toolkit/data/SC/mariko/ram_vddq.json b/Ultrahand/OC Toolkit/data/SC/mariko/ram_vddq.json deleted file mode 100644 index 683429e4..00000000 --- a/Ultrahand/OC Toolkit/data/SC/mariko/ram_vddq.json +++ /dev/null @@ -1,292 +0,0 @@ -[ - { - "name": "Do not override", - "label": "Do not override", - "hex": "000000" - }, - { - "name": "370 mV", - "label": "370 mV - unsafe", - "hex": "50A505" - }, - { - "name": "375 mV", - "label": "375 mV - unsafe", - "hex": "D8B805" - }, - { - "name": "380 mV", - "label": "380 mV - unsafe", - "hex": "60CC05" - }, - { - "name": "385 mV", - "label": "385 mV - unsafe", - "hex": "E8DF05" - }, - { - "name": "390 mV", - "label": "390 mV - unsafe", - "hex": "70F305" - }, - { - "name": "395 mV", - "label": "395 mV - unsafe", - "hex": "F80606" - }, - { - "name": "400 mV", - "label": "400 mV - unsafe", - "hex": "801A06" - }, - { - "name": "405 mV", - "label": "405 mV - unsafe", - "hex": "082E06" - }, - { - "name": "410 mV", - "label": "410 mV - unsafe", - "hex": "904106" - }, - { - "name": "415 mV", - "label": "415 mV - unsafe", - "hex": "185506" - }, - { - "name": "420 mV", - "label": "420 mV - unsafe", - "hex": "A06806" - }, - { - "name": "425 mV", - "label": "425 mV - unsafe", - "hex": "287C06" - }, - { - "name": "430 mV", - "label": "430 mV - unsafe", - "hex": "B08F06" - }, - { - "name": "435 mV", - "label": "435 mV - unsafe", - "hex": "38A306" - }, - { - "name": "440 mV", - "label": "440 mV - unsafe", - "hex": "C0B606" - }, - { - "name": "445 mV", - "label": "445 mV - unsafe", - "hex": "48CA06" - }, - { - "name": "450 mV", - "label": "450 mV - unsafe", - "hex": "D0DD06" - }, - { - "name": "455 mV", - "label": "455 mV - unsafe", - "hex": "58F106" - }, - { - "name": "460 mV", - "label": "460 mV - unsafe", - "hex": "E00407" - }, - { - "name": "465 mV", - "label": "465 mV - unsafe", - "hex": "681807" - }, - { - "name": "470 mV", - "label": "470 mV - unsafe", - "hex": "F02B07" - }, - { - "name": "475 mV", - "label": "475 mV - unsafe", - "hex": "783F07" - }, - { - "name": "480 mV", - "label": "480 mV - unsafe", - "hex": "005307" - }, - { - "name": "485 mV", - "label": "485 mV - unsafe", - "hex": "886607" - }, - { - "name": "490 mV", - "label": "490 mV - unsafe", - "hex": "107A07" - }, - { - "name": "495 mV", - "label": "495 mV - unsafe", - "hex": "988D07" - }, - { - "name": "500 mV", - "label": "500 mV - unsafe", - "hex": "20A107" - }, - { - "name": "505 mV", - "label": "505 mV - unsafe", - "hex": "A8B407" - }, - { - "name": "510 mV", - "label": "510 mV - unsafe", - "hex": "30C807" - }, - { - "name": "515 mV", - "label": "515 mV - unsafe", - "hex": "B8DB07" - }, - { - "name": "520 mV", - "label": "520 mV - unsafe", - "hex": "40EF07" - }, - { - "name": "525 mV", - "label": "525 mV - unsafe", - "hex": "C80208" - }, - { - "name": "530 mV", - "label": "530 mV - unsafe", - "hex": "501608" - }, - { - "name": "535 mV", - "label": "535 mV - unsafe", - "hex": "D82908" - }, - { - "name": "540 mV", - "label": "540 mV - unsafe", - "hex": "603D08" - }, - { - "name": "545 mV", - "label": "545 mV - unsafe", - "hex": "E85008" - }, - { - "name": "550 mV", - "label": "550 mV", - "hex": "706408" - }, - { - "name": "555 mV", - "label": "555 mV", - "hex": "F87708" - }, - { - "name": "560 mV", - "label": "560 mV", - "hex": "808B08" - }, - { - "name": "565 mV", - "label": "565 mV", - "hex": "089F08" - }, - { - "name": "570 mV", - "label": "570 mV", - "hex": "90B208" - }, - { - "name": "575 mV", - "label": "575 mV", - "hex": "18C608" - }, - { - "name": "580 mV", - "label": "580 mV", - "hex": "A0D908" - }, - { - "name": "585 mV", - "label": "585 mV", - "hex": "28ED08" - }, - { - "name": "590 mV", - "label": "590 mV", - "hex": "B00009" - }, - { - "name": "595 mV", - "label": "595 mV", - "hex": "381409" - }, - { - "name": "600 mV", - "label": "600 mV - default", - "hex": "C02709" - }, - { - "name": "605 mV", - "label": "605 mV", - "hex": "483B09" - }, - { - "name": "610 mV", - "label": "610 mV", - "hex": "D04E09" - }, - { - "name": "615 mV", - "label": "615 mV", - "hex": "586209" - }, - { - "name": "620 mV", - "label": "620 mV", - "hex": "E07509" - }, - { - "name": "625 mV", - "label": "625 mV", - "hex": "688909" - }, - { - "name": "630 mV", - "label": "630 mV", - "hex": "F09C09" - }, - { - "name": "635 mV", - "label": "635 mV", - "hex": "78B009" - }, - { - "name": "640 mV", - "label": "640 mV", - "hex": "00C409" - }, - { - "name": "645 mV", - "label": "645 mV", - "hex": "88D709" - }, - { - "name": "650 mV", - "label": "650 mV", - "hex": "10EB09" - } -] diff --git a/Ultrahand/OC Toolkit/data/SC/update.ini b/Ultrahand/OC Toolkit/data/SC/update.ini deleted file mode 100644 index da0a6d25..00000000 --- a/Ultrahand/OC Toolkit/data/SC/update.ini +++ /dev/null @@ -1,193 +0,0 @@ -;title='OC Toolkit' -;creator='ppkantorski, B3711' -;about='This package was designed for advance overclock configurations. Use with caution and proper guidance.' - - -[@Software Update] - -[Version] -;mode=table -;background=true -;gap=20 -ini_file './config.ini' -'Latest Version' = '{ini_file(Update,online)}' - -[Update OC Toolkit] -try: -download https://github.com/ppkantorski/Ultrahand-Overlay/releases/latest/download/ovlmenu.ovl /config/ultrahand/downloads/ -move /config/ultrahand/downloads/ovlmenu.ovl /switch/.overlays/ovlmenu.ovl -download https://github.com/halop/OC_Toolkit_SC_EOS/releases/latest/download/OC.Toolkit.u.zip /config/ultrahand/downloads/ -unzip /config/ultrahand/downloads/OC.Toolkit.u.zip /config/ultrahand/downloads/OC.Toolkit/ -move './config.ini' '/config/ultrahand/downloads/OC.Toolkit/OC Toolkit/' -delete './' -move '/config/ultrahand/downloads/OC.Toolkit/OC Toolkit/' './' -delete /config/ultrahand/downloads/OC.Toolkit.u.zip -delete /config/ultrahand/downloads/OC.Toolkit/ - -[gap] -;mode=table -;background=false -;gap=30 - -[Update loader.kip] -try: -download https://github.com/halop/OC_Toolkit_SC_EOS/releases/latest/download/kip.zip /config/ultrahand/downloads/ -set-ini-val './config.ini' Backup Path 'upd' -clear hex_sum_cache -hex_file '/atmosphere/kips/loader.kip' -ini_file './config.ini' -mkdir /atmosphere/kips/.bakTK/ -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuBoost {hex_file(CUST,8,3)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuUVL {hex_file(CUST,12,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuUVH {hex_file(CUST,252,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuVminE {hex_file(CUST,16,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuVmaxE {hex_file(CUST,20,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuVminL {hex_file(CUST,24,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuVminH {hex_file(CUST,28,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuVmaxM {hex_file(CUST,32,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuUVE {hex_file(CUST,36,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuUVM {hex_file(CUST,40,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuOFF {hex_file(CUST,44,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuVminE {hex_file(CUST,48,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuSpeedo {hex_file(CUST,52,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuVminM {hex_file(CUST,56,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuVmax {hex_file(CUST,60,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup DRAM {hex_file(CUST,64,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup ramVDD2 {hex_file(CUST,68,3)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup ramVDDQ {hex_file(CUST,72,3)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup ramMHzE {hex_file(CUST,76,3)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup ramMHzM {hex_file(CUST,80,3)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup DVB {hex_file(CUST,84,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T1 {hex_file(CUST,88,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T2 {hex_file(CUST,92,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T3 {hex_file(CUST,96,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T4 {hex_file(CUST,100,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T5 {hex_file(CUST,104,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T6 {hex_file(CUST,108,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T7 {hex_file(CUST,112,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T8 {hex_file(CUST,116,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 76UV3 {hex_file(CUST,124,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 153UV3 {hex_file(CUST,128,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 230UV3 {hex_file(CUST,132,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 307UV3 {hex_file(CUST,136,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 384UV3 {hex_file(CUST,140,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 460UV3 {hex_file(CUST,144,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 537UV3 {hex_file(CUST,148,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 614UV3 {hex_file(CUST,152,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 691UV3 {hex_file(CUST,156,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 768UV3 {hex_file(CUST,160,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 844UV3 {hex_file(CUST,164,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 921UV3 {hex_file(CUST,168,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 998UV3 {hex_file(CUST,172,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1075UV3 {hex_file(CUST,176,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1152UV3 {hex_file(CUST,180,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1228UV3 {hex_file(CUST,184,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1267UV3 {hex_file(CUST,188,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1305UV3 {hex_file(CUST,192,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1344UV3 {hex_file(CUST,196,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1382UV3 {hex_file(CUST,200,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1420UV3 {hex_file(CUST,204,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1459UV3 {hex_file(CUST,208,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1497UV3 {hex_file(CUST,212,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1536UV3 {hex_file(CUST,216,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1305GPU {hex_file(CUST,256,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup CPUUL {hex_file(CUST,264,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup CPUTABLE {hex_file(CUST,272,2)} - -remove-ini-section './config.ini' Backup - -unzip /config/ultrahand/downloads/kip.zip /config/ultrahand/downloads/kip/ -move /atmosphere/kips/loader.kip '/atmosphere/kips/.bakTK/loader.kip.backup' -move /config/ultrahand/downloads/kip/loader.kip '/atmosphere/kips/loader.kip' -delete /config/ultrahand/downloads/kip.zip -delete /config/ultrahand/downloads/kip/ -delete '/atmosphere/kips/loader.kip.backup' - - -set-ini-val './config.ini' Backup Path '/atmosphere/kips/.bakTK/Backup upd.ini' -clear hex_sum_cache -ini_file './config.ini' -ini_file '{ini_file(Backup,Path)}' - -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 8 {ini_file(Backup,cpuBoost)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 12 {ini_file(Backup,cpuUVL)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 252 {ini_file(Backup,cpuUVH)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 16 {ini_file(Backup,cpuVminE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 20 {ini_file(Backup,cpuVmaxE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 24 {ini_file(Backup,cpuVminL)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 28 {ini_file(Backup,cpuVminH)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 32 {ini_file(Backup,cpuVmaxM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 36 {ini_file(Backup,gpuUVE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 40 {ini_file(Backup,gpuUVM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 44 {ini_file(Backup,gpuOFF)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 48 {ini_file(Backup,gpuVminE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 52 {ini_file(Backup,gpuSpeedo)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 56 {ini_file(Backup,gpuVminM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 60 {ini_file(Backup,gpuVmax)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 64 {ini_file(Backup,DRAM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 68 {ini_file(Backup,ramVDD2)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 72 {ini_file(Backup,ramVDDQ)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 76 {ini_file(Backup,ramMHzE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 80 {ini_file(Backup,ramMHzM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 84 {ini_file(Backup,DVB)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 {ini_file(Backup,T1)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 {ini_file(Backup,T2)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 {ini_file(Backup,T3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 {ini_file(Backup,T4)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 {ini_file(Backup,T5)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 {ini_file(Backup,T6)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 {ini_file(Backup,T7)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 {ini_file(Backup,T8)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 124 {ini_file(Backup,76UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 128 {ini_file(Backup,153UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 132 {ini_file(Backup,230UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 136 {ini_file(Backup,307UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 140 {ini_file(Backup,384UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 144 {ini_file(Backup,460UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 148 {ini_file(Backup,537UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 152 {ini_file(Backup,614UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 156 {ini_file(Backup,691UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 160 {ini_file(Backup,768UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 164 {ini_file(Backup,844UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 168 {ini_file(Backup,921UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 172 {ini_file(Backup,998UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 176 {ini_file(Backup,1075UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 180 {ini_file(Backup,1152UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 184 {ini_file(Backup,1228UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 188 {ini_file(Backup,1267UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 192 {ini_file(Backup,1305UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 196 {ini_file(Backup,1344UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 200 {ini_file(Backup,1382UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 204 {ini_file(Backup,1420UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 208 {ini_file(Backup,1459UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 212 {ini_file(Backup,1497UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 216 {ini_file(Backup,1536UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 256 {ini_file(Backup,1305GPU)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 264 {ini_file(Backup,CPUUL)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 272 {ini_file(Backup,CPUTABLE)} -delete '/atmosphere/kips/.bakTK/Backup upd.ini' -exec boot - - -[gap] -;mode=table -;background=false -;gap=30 - - -[Update sys-clk-eos] -try: -download https://github.com/halop/OC_Toolkit_SC_EOS/releases/latest/download/sys-clk.zip /config/ultrahand/downloads/ -unzip /config/ultrahand/downloads/sys-clk.zip /config/ultrahand/downloads/sys-clk/ -move '/config/ultrahand/downloads/sys-clk/' '/' -delete /config/ultrahand/downloads/sys-clk.zip -delete /config/ultrahand/downloads/sys-clk/ - - -[gap] -;mode=table -;background=false -;gap=30 - - -[Package Info] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/default_table.ini b/Ultrahand/OC Toolkit/default_table.ini deleted file mode 100644 index b83305ae..00000000 --- a/Ultrahand/OC Toolkit/default_table.ini +++ /dev/null @@ -1,59 +0,0 @@ -;creator='ppkantorski, B3711' - -[Default Table] - -[yes] -;mode=table -;background=true -;spacing=8 -;gap=50 -;info_text_color=warning -'' = 'Reset the table to default values. ' -'' = '' -'' = 'Are you sure you want to proceed? ' - -[Yes - Apply] -;system=mariko -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 124 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 128 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 132 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 136 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 140 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 144 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 148 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 152 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 156 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 160 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 164 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 168 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 172 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 176 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 180 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 184 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 188 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 192 0000 -exec cCutomTable -back - -[Yes - Apply] -;system=erista -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 124 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 128 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 132 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 136 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 140 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 144 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 148 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 152 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 156 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 160 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 164 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 168 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 172 0000 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 176 D007 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 180 D007 -exec cCutomTable -back - -[No - Go back] -back \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/erista/cpu_boost_clock.json b/Ultrahand/OC Toolkit/erista/cpu_boost_clock.json deleted file mode 100644 index 5884c7bd..00000000 --- a/Ultrahand/OC Toolkit/erista/cpu_boost_clock.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - { - "name": "1785 MHz", - "label": "1785 MHz - default", - "hex": "A83C1B" - }, - { - "name": "1887 MHz", - "label": "1887 MHz", - "hex": "18CB1C" - }, - { - "name": "1963 MHz", - "label": "1963 MHz", - "hex": "F8F31D" - }, - { - "name": "2091 MHz", - "label": "2091 MHz", - "hex": "F8E71F" - }, - { - "name": "2193 MHz", - "label": "2193 MHz", - "hex": "687621" - }, - { - "name": "2295 MHz", - "label": "2295 MHz", - "hex": "D80423" - } -] diff --git a/Ultrahand/OC Toolkit/erista/cpu_low_vmin.json b/Ultrahand/OC Toolkit/erista/cpu_low_vmin.json deleted file mode 100644 index 9d6293e9..00000000 --- a/Ultrahand/OC Toolkit/erista/cpu_low_vmin.json +++ /dev/null @@ -1,27 +0,0 @@ -[ - { - "name": "750 mV", - "label": "750 mV - unsafe", - "hex": "EE02" - }, - { - "name": "775 mV", - "label": "775 mV - unsafe", - "hex": "0703" - }, - { - "name": "800 mV", - "label": "800 mV", - "hex": "2003" - }, - { - "name": "825 mV", - "label": "825 mV", - "hex": "3903" - }, - { - "name": "850 mV", - "label": "850 mV", - "hex": "5203" - } -] diff --git a/Ultrahand/OC Toolkit/erista/cpu_uv.json b/Ultrahand/OC Toolkit/erista/cpu_uv.json deleted file mode 100644 index 77fa73fe..00000000 --- a/Ultrahand/OC Toolkit/erista/cpu_uv.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - { - "name": "0", - "label": " 0", - "hex": "00" - }, - { - "name": "1", - "label": " 1", - "hex": "01" - }, - { - "name": "2", - "label": " 2", - "hex": "02" - }, - { - "name": "3", - "label": " 3", - "hex": "03" - }, - { - "name": "4", - "label": " 4", - "hex": "04" - }, - { - "name": "5", - "label": " 5", - "hex": "05" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/erista/cpu_voltages.json b/Ultrahand/OC Toolkit/erista/cpu_voltages.json deleted file mode 100644 index b6eed687..00000000 --- a/Ultrahand/OC Toolkit/erista/cpu_voltages.json +++ /dev/null @@ -1,62 +0,0 @@ -[ - { - "name": "1200 mV", - "label": "1200 mV", - "dec": "1200" - }, - { - "name": "1205 mV", - "label": "1205 mV", - "dec": "1205" - }, - { - "name": "1210 mV", - "label": "1210 mV", - "dec": "1210" - }, - { - "name": "1215 mV", - "label": "1215 mV", - "dec": "1215" - }, - { - "name": "1220 mV", - "label": "1220 mV", - "dec": "1220" - }, - { - "name": "1225 mV", - "label": "1225 mV", - "dec": "1225" - }, - { - "name": "1230 mV", - "label": "1230 mV", - "dec": "1230" - }, - { - "name": "1235 mV", - "label": "1235 mV", - "dec": "1235" - }, - { - "name": "1240 mV", - "label": "1240 mV", - "dec": "1240" - }, - { - "name": "1245 mV", - "label": "1245 mV", - "dec": "1245" - }, - { - "name": "1250 mV", - "label": "1250 mV", - "dec": "1250" - }, - { - "name": "1257 mV", - "label": "1257 mV - Default", - "dec": "1257" - } -] diff --git a/Ultrahand/OC Toolkit/erista/gpu_uv.json b/Ultrahand/OC Toolkit/erista/gpu_uv.json deleted file mode 100644 index 4c4dba77..00000000 --- a/Ultrahand/OC Toolkit/erista/gpu_uv.json +++ /dev/null @@ -1,17 +0,0 @@ -[ - { - "name": "0", - "label": " Default Table 0", - "hex": "00" - }, - { - "name": "1", - "label": " M static +30mV 1", - "hex": "01" - }, - { - "name": "2", - "label": " high UV table 2", - "hex": "02" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/erista/gpu_uv3.json b/Ultrahand/OC Toolkit/erista/gpu_uv3.json deleted file mode 100644 index 16ec74b0..00000000 --- a/Ultrahand/OC Toolkit/erista/gpu_uv3.json +++ /dev/null @@ -1,267 +0,0 @@ -[ - { - "name": "Auto", - "hex": "0000", - "label": "Auto" - }, - { - "name": "disabled", - "hex": "D007", - "label": "disabled" - }, - { - "name": "700 mV", - "hex": "BC02", - "label": "700 mV" - }, - { - "name": "705 mV", - "hex": "C102", - "label": "705 mV" - }, - { - "name": "710 mV", - "hex": "C602", - "label": "710 mV" - }, - { - "name": "715 mV", - "hex": "CB02", - "label": "715 mV" - }, - { - "name": "720 mV", - "hex": "D002", - "label": "720 mV" - }, - { - "name": "725 mV", - "hex": "D502", - "label": "725 mV" - }, - { - "name": "730 mV", - "hex": "DA02", - "label": "730 mV" - }, - { - "name": "735 mV", - "hex": "DF02", - "label": "735 mV" - }, - { - "name": "740 mV", - "hex": "E402", - "label": "740 mV" - }, - { - "name": "745 mV", - "hex": "E902", - "label": "745 mV" - }, - { - "name": "750 mV", - "hex": "EE02", - "label": "750 mV" - }, - { - "name": "755 mV", - "hex": "F302", - "label": "755 mV" - }, - { - "name": "760 mV", - "hex": "F802", - "label": "760 mV" - }, - { - "name": "765 mV", - "hex": "FD02", - "label": "765 mV" - }, - { - "name": "770 mV", - "hex": "0203", - "label": "770 mV" - }, - { - "name": "775 mV", - "hex": "0703", - "label": "775 mV" - }, - { - "name": "780 mV", - "hex": "0C03", - "label": "780 mV" - }, - { - "name": "785 mV", - "hex": "1103", - "label": "785 mV" - }, - { - "name": "790 mV", - "hex": "1603", - "label": "790 mV" - }, - { - "name": "795 mV", - "hex": "1B03", - "label": "795 mV" - }, - { - "name": "800 mV", - "hex": "2003", - "label": "800 mV" - }, - { - "name": "805 mV", - "hex": "2503", - "label": "805 mV" - }, - { - "name": "810 mV", - "hex": "2A03", - "label": "810 mV" - }, - { - "name": "815 mV", - "hex": "2F03", - "label": "815 mV" - }, - { - "name": "820 mV", - "hex": "3403", - "label": "820 mV" - }, - { - "name": "825 mV", - "hex": "3903", - "label": "825 mV" - }, - { - "name": "830 mV", - "hex": "3E03", - "label": "830 mV" - }, - { - "name": "835 mV", - "hex": "4303", - "label": "835 mV" - }, - { - "name": "840 mV", - "hex": "4803", - "label": "840 mV" - }, - { - "name": "845 mV", - "hex": "4D03", - "label": "845 mV" - }, - { - "name": "850 mV", - "hex": "5203", - "label": "850 mV" - }, - { - "name": "855 mV", - "hex": "5703", - "label": "855 mV" - }, - { - "name": "860 mV", - "hex": "5C03", - "label": "860 mV" - }, - { - "name": "865 mV", - "hex": "6103", - "label": "865 mV" - }, - { - "name": "870 mV", - "hex": "6603", - "label": "870 mV" - }, - { - "name": "875 mV", - "hex": "6B03", - "label": "875 mV" - }, - { - "name": "880 mV", - "hex": "7003", - "label": "880 mV" - }, - { - "name": "885 mV", - "hex": "7503", - "label": "885 mV" - }, - { - "name": "890 mV", - "hex": "7A03", - "label": "890 mV" - }, - { - "name": "895 mV", - "hex": "7F03", - "label": "895 mV" - }, - { - "name": "900 mV", - "hex": "8403", - "label": "900 mV" - }, - { - "name": "905 mV", - "hex": "8903", - "label": "905 mV" - }, - { - "name": "910 mV", - "hex": "8E03", - "label": "910 mV" - }, - { - "name": "915 mV", - "hex": "9303", - "label": "915 mV" - }, - { - "name": "920 mV", - "hex": "9803", - "label": "920 mV" - }, - { - "name": "925 mV", - "hex": "9D03", - "label": "925 mV" - }, - { - "name": "930 mV", - "hex": "A203", - "label": "930 mV" - }, - { - "name": "935 mV", - "hex": "A703", - "label": "935 mV" - }, - { - "name": "940 mV", - "hex": "AC03", - "label": "940 mV" - }, - { - "name": "945 mV", - "hex": "B103", - "label": "945 mV" - }, - { - "name": "950 mV", - "hex": "B603", - "label": "950 mV" - } -] diff --git a/Ultrahand/OC Toolkit/erista/gpu_uv3_e.json b/Ultrahand/OC Toolkit/erista/gpu_uv3_e.json deleted file mode 100644 index ec871112..00000000 --- a/Ultrahand/OC Toolkit/erista/gpu_uv3_e.json +++ /dev/null @@ -1,262 +0,0 @@ -[ - { - "name": "disabled", - "hex": "D007", - "label": "disabled" - }, - { - "name": "700 mV", - "hex": "BC02", - "label": "700 mV" - }, - { - "name": "705 mV", - "hex": "C102", - "label": "705 mV" - }, - { - "name": "710 mV", - "hex": "C602", - "label": "710 mV" - }, - { - "name": "715 mV", - "hex": "CB02", - "label": "715 mV" - }, - { - "name": "720 mV", - "hex": "D002", - "label": "720 mV" - }, - { - "name": "725 mV", - "hex": "D502", - "label": "725 mV" - }, - { - "name": "730 mV", - "hex": "DA02", - "label": "730 mV" - }, - { - "name": "735 mV", - "hex": "DF02", - "label": "735 mV" - }, - { - "name": "740 mV", - "hex": "E402", - "label": "740 mV" - }, - { - "name": "745 mV", - "hex": "E902", - "label": "745 mV" - }, - { - "name": "750 mV", - "hex": "EE02", - "label": "750 mV" - }, - { - "name": "755 mV", - "hex": "F302", - "label": "755 mV" - }, - { - "name": "760 mV", - "hex": "F802", - "label": "760 mV" - }, - { - "name": "765 mV", - "hex": "FD02", - "label": "765 mV" - }, - { - "name": "770 mV", - "hex": "0203", - "label": "770 mV" - }, - { - "name": "775 mV", - "hex": "0703", - "label": "775 mV" - }, - { - "name": "780 mV", - "hex": "0C03", - "label": "780 mV" - }, - { - "name": "785 mV", - "hex": "1103", - "label": "785 mV" - }, - { - "name": "790 mV", - "hex": "1603", - "label": "790 mV" - }, - { - "name": "795 mV", - "hex": "1B03", - "label": "795 mV" - }, - { - "name": "800 mV", - "hex": "2003", - "label": "800 mV" - }, - { - "name": "805 mV", - "hex": "2503", - "label": "805 mV" - }, - { - "name": "810 mV", - "hex": "2A03", - "label": "810 mV" - }, - { - "name": "815 mV", - "hex": "2F03", - "label": "815 mV" - }, - { - "name": "820 mV", - "hex": "3403", - "label": "820 mV" - }, - { - "name": "825 mV", - "hex": "3903", - "label": "825 mV" - }, - { - "name": "830 mV", - "hex": "3E03", - "label": "830 mV" - }, - { - "name": "835 mV", - "hex": "4303", - "label": "835 mV" - }, - { - "name": "840 mV", - "hex": "4803", - "label": "840 mV" - }, - { - "name": "845 mV", - "hex": "4D03", - "label": "845 mV" - }, - { - "name": "850 mV", - "hex": "5203", - "label": "850 mV" - }, - { - "name": "855 mV", - "hex": "5703", - "label": "855 mV" - }, - { - "name": "860 mV", - "hex": "5C03", - "label": "860 mV" - }, - { - "name": "865 mV", - "hex": "6103", - "label": "865 mV" - }, - { - "name": "870 mV", - "hex": "6603", - "label": "870 mV" - }, - { - "name": "875 mV", - "hex": "6B03", - "label": "875 mV" - }, - { - "name": "880 mV", - "hex": "7003", - "label": "880 mV" - }, - { - "name": "885 mV", - "hex": "7503", - "label": "885 mV" - }, - { - "name": "890 mV", - "hex": "7A03", - "label": "890 mV" - }, - { - "name": "895 mV", - "hex": "7F03", - "label": "895 mV" - }, - { - "name": "900 mV", - "hex": "8403", - "label": "900 mV" - }, - { - "name": "905 mV", - "hex": "8903", - "label": "905 mV" - }, - { - "name": "910 mV", - "hex": "8E03", - "label": "910 mV" - }, - { - "name": "915 mV", - "hex": "9303", - "label": "915 mV" - }, - { - "name": "920 mV", - "hex": "9803", - "label": "920 mV" - }, - { - "name": "925 mV", - "hex": "9D03", - "label": "925 mV" - }, - { - "name": "930 mV", - "hex": "A203", - "label": "930 mV" - }, - { - "name": "935 mV", - "hex": "A703", - "label": "935 mV" - }, - { - "name": "940 mV", - "hex": "AC03", - "label": "940 mV" - }, - { - "name": "945 mV", - "hex": "B103", - "label": "945 mV" - }, - { - "name": "950 mV", - "hex": "B603", - "label": "950 mV" - } -] diff --git a/Ultrahand/OC Toolkit/erista/gpu_vmin.json b/Ultrahand/OC Toolkit/erista/gpu_vmin.json deleted file mode 100644 index 12dc5911..00000000 --- a/Ultrahand/OC Toolkit/erista/gpu_vmin.json +++ /dev/null @@ -1,207 +0,0 @@ -[ - { - "name": "700 mV", - "label": "700 mV", - "dec": "700" - }, - { - "name": "705 mV", - "label": "705 mV", - "dec": "705" - }, - { - "name": "710 mV", - "label": "710 mV", - "dec": "710" - }, - { - "name": "715 mV", - "label": "715 mV", - "dec": "715" - }, - { - "name": "720 mV", - "label": "720 mV", - "dec": "720" - }, - { - "name": "725 mV", - "label": "725 mV", - "dec": "725" - }, - { - "name": "730 mV", - "label": "730 mV", - "dec": "730" - }, - { - "name": "735 mV", - "label": "735 mV", - "dec": "735" - }, - { - "name": "740 mV", - "label": "740 mV", - "dec": "740" - }, - { - "name": "745 mV", - "label": "745 mV", - "dec": "745" - }, - { - "name": "750 mV", - "label": "750 mV", - "dec": "750" - }, - { - "name": "755 mV", - "label": "755 mV", - "dec": "755" - }, - { - "name": "760 mV", - "label": "760 mV", - "dec": "760" - }, - { - "name": "765 mV", - "label": "765 mV", - "dec": "765" - }, - { - "name": "770 mV", - "label": "770 mV", - "dec": "770" - }, - { - "name": "775 mV", - "label": "775 mV", - "dec": "775" - }, - { - "name": "780 mV", - "label": "780 mV", - "dec": "780" - }, - { - "name": "785 mV", - "label": "785 mV", - "dec": "785" - }, - { - "name": "790 mV", - "label": "790 mV", - "dec": "790" - }, - { - "name": "795 mV", - "label": "795 mV", - "dec": "795" - }, - { - "name": "800 mV", - "label": "800 mV", - "dec": "800" - }, - { - "name": "805 mV", - "label": "805 mV", - "dec": "805" - }, - { - "name": "810 mV", - "label": "810 mV - Default", - "dec": "810" - }, - { - "name": "815 mV", - "label": "815 mV", - "dec": "815" - }, - { - "name": "820 mV", - "label": "820 mV", - "dec": "820" - }, - { - "name": "825 mV", - "label": "825 mV", - "dec": "825" - }, - { - "name": "830 mV", - "label": "830 mV", - "dec": "830" - }, - { - "name": "835 mV", - "label": "835 mV", - "dec": "835" - }, - { - "name": "840 mV", - "label": "840 mV", - "dec": "840" - }, - { - "name": "845 mV", - "label": "845 mV", - "dec": "845" - }, - { - "name": "850 mV", - "label": "850 mV", - "dec": "850" - }, - { - "name": "855 mV", - "label": "855 mV", - "dec": "855" - }, - { - "name": "860 mV", - "label": "860 mV", - "dec": "860" - }, - { - "name": "865 mV", - "label": "865 mV", - "dec": "865" - }, - { - "name": "870 mV", - "label": "870 mV", - "dec": "870" - }, - { - "name": "875 mV", - "label": "875 mV", - "dec": "875" - }, - { - "name": "880 mV", - "label": "880 mV", - "dec": "880" - }, - { - "name": "885 mV", - "label": "885 mV", - "dec": "885" - }, - { - "name": "890 mV", - "label": "890 mV", - "dec": "890" - }, - { - "name": "895 mV", - "label": "895 mV", - "dec": "895" - }, - { - "name": "900 mV", - "label": "900 mV", - "dec": "900" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/erista/ram_dvb_table.json b/Ultrahand/OC Toolkit/erista/ram_dvb_table.json deleted file mode 100644 index 5cbb0014..00000000 --- a/Ultrahand/OC Toolkit/erista/ram_dvb_table.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - { - "name": "0", - "label": " 0", - "hex": "00000000" - }, - { - "name": "1", - "label": " 1", - "hex": "01000000" - }, - { - "name": "2", - "label": " 2", - "hex": "02000000" - }, - { - "name": "3", - "label": " 3", - "hex": "03000000" - }, - { - "name": "4", - "label": " 4", - "hex": "04000000" - }, - { - "name": "5", - "label": " 5", - "hex": "05000000" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/erista/ram_freqs.json b/Ultrahand/OC Toolkit/erista/ram_freqs.json deleted file mode 100644 index 4006c260..00000000 --- a/Ultrahand/OC Toolkit/erista/ram_freqs.json +++ /dev/null @@ -1,147 +0,0 @@ -[ - { - "name": "1862 MHz - Default", - "label": "1862 MHz", - "dec": "1862400" - }, - { - "name": "1881 MHz", - "label": "1881 MHz", - "dec": "1881600" - }, - { - "name": "1900 MHz", - "label": "1900 MHz", - "dec": "1900800" - }, - { - "name": "1920 MHz", - "label": "1920 MHz", - "dec": "1920000" - }, - { - "name": "1939 MHz", - "label": "1939 MHz", - "dec": "1939200" - }, - { - "name": "1958 MHz", - "label": "1958 MHz", - "dec": "1958400" - }, - { - "name": "1977 MHz", - "label": "1977 MHz", - "dec": "1977600" - }, - { - "name": "1996 MHz", - "label": "1996 MHz", - "dec": "1996800" - }, - { - "name": "2016 MHz", - "label": "2016 MHz", - "dec": "2016000" - }, - { - "name": "2035 MHz", - "label": "2035 MHz", - "dec": "2035200" - }, - { - "name": "2054 MHz", - "label": "2054 MHz", - "dec": "2054400" - }, - { - "name": "2073 MHz", - "label": "2073 MHz", - "dec": "2073600" - }, - { - "name": "2092 MHz", - "label": "2092 MHz", - "dec": "2092800" - }, - { - "name": "2112 MHz", - "label": "2112 MHz", - "dec": "2112000" - }, - { - "name": "2131 MHz", - "label": "2131 MHz", - "dec": "2131200" - }, - { - "name": "2150 MHz", - "label": "2150 MHz", - "dec": "2150400" - }, - { - "name": "2169 MHz", - "label": "2169 MHz", - "dec": "2169600" - }, - { - "name": "2188 MHz", - "label": "2188 MHz", - "dec": "2188800" - }, - { - "name": "2208 MHz", - "label": "2208 MHz", - "dec": "2208000" - }, - { - "name": "2227 MHz", - "label": "2227 MHz", - "dec": "2227200" - }, - { - "name": "2246 MHz", - "label": "2246 MHz", - "dec": "2246400" - }, - { - "name": "2265 MHz", - "label": "2265 MHz", - "dec": "2265600" - }, - { - "name": "2284 MHz", - "label": "2284 MHz", - "dec": "2284800" - }, - { - "name": "2304 MHz", - "label": "2304 MHz", - "dec": "2304000" - }, - { - "name": "2323 MHz", - "label": "2323 MHz", - "dec": "2323200" - }, - { - "name": "2342 MHz", - "label": "2342 MHz", - "dec": "2342400" - }, - { - "name": "2361 MHz", - "label": "2361 MHz", - "dec": "2361600" - }, - { - "name": "2380 MHz", - "label": "2380 MHz", - "dec": "2380800" - }, - { - "name": "2400 MHz", - "label": "2400 MHz", - "dec": "2400000" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/erista/ram_trfc.json b/Ultrahand/OC Toolkit/erista/ram_trfc.json deleted file mode 100644 index 994bee28..00000000 --- a/Ultrahand/OC Toolkit/erista/ram_trfc.json +++ /dev/null @@ -1,32 +0,0 @@ -[ - { - "name": "(90) 0", - "label": "0", - "hex": "00" - }, - { - "name": "(80) 1", - "label": "1", - "hex": "01" - }, - { - "name": "(70) 2", - "label": "2", - "hex": "02" - }, - { - "name": "(60) 3", - "label": "3", - "hex": "03" - }, - { - "name": "(50) 4", - "label": "4", - "hex": "04" - }, - { - "name": "(40) 5", - "label": "5", - "hex": "05" - } -] diff --git a/Ultrahand/OC Toolkit/erista/ram_vdd2.json b/Ultrahand/OC Toolkit/erista/ram_vdd2.json deleted file mode 100644 index b68569e5..00000000 --- a/Ultrahand/OC Toolkit/erista/ram_vdd2.json +++ /dev/null @@ -1,87 +0,0 @@ -[ - { - "name": "Do not override", - "label": "Do not override", - "hex": "000000" - }, - { - "name": "1050 mV", - "label": "1050 mV", - "hex": "900510" - }, - { - "name": "1062.5 mV", - "label": "1062.5 mV", - "hex": "643610" - }, - { - "name": "1075 mV", - "label": "1075 mV", - "hex": "386710" - }, - { - "name": "1087.5 mV", - "label": "1087.5 mV", - "hex": "0C9810" - }, - { - "name": "1100 mV", - "label": "1100 mV", - "hex": "E0C810" - }, - { - "name": "1112.5 mV", - "label": "1112.5 mV", - "hex": "B4F910" - }, - { - "name": "1125 mV", - "label": "1125 mV - default", - "hex": "882A11" - }, - { - "name": "1137.5 mV", - "label": "1137.5 mV", - "hex": "5C5B11" - }, - { - "name": "1150 mV", - "label": "1150 mV", - "hex": "308C11" - }, - { - "name": "1162.5 mV", - "label": "1162.5 mV", - "hex": "04BD11" - }, - { - "name": "1175 mV", - "label": "1175 mV", - "hex": "D8ED11" - }, - { - "name": "1187.5 mV", - "label": "1187.5 mV", - "hex": "AC1E12" - }, - { - "name": "1200 mV", - "label": "1200 mV", - "hex": "804F12" - }, - { - "name": "1212.5 mV", - "label": "1212.5 mV", - "hex": "548012" - }, - { - "name": "1225 mV", - "label": "1225 mV - unsafe", - "hex": "28B112" - }, - { - "name": "1237.5 mV", - "label": "1237.5 mV - unsafe", - "hex": "FCE112" - } -] diff --git a/Ultrahand/OC Toolkit/extended_voltages.ini b/Ultrahand/OC Toolkit/extended_voltages.ini deleted file mode 100644 index 051daad2..00000000 --- a/Ultrahand/OC Toolkit/extended_voltages.ini +++ /dev/null @@ -1,32 +0,0 @@ -;creator='ppkantorski, B3711' - -[Warning] - -[yes] -;mode=table -;alignment=right -;background=true -;spacing=8 -;gap=50 -;info_text_color=warning -'' = 'High voltages and exceeding PMIC and board' -'' = 'limits can cause hardware degradation. ' -'' = '' -'' = 'Unlock extended voltages only if you ' -'' = 'fully understand the risks. ' -'' = '' -'' = 'Are you sure you want to proceed? ' - -[Yes - Apply] -copy '/switch/.packages/OC Toolkit/data/SC/' './' -mariko: -exec boot -back -erista: -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 176 D007 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 180 D007 -exec boot -back - -[No - Go back] -back \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/fan_curve.ini b/Ultrahand/OC Toolkit/fan_curve.ini deleted file mode 100644 index b77f49b4..00000000 --- a/Ultrahand/OC Toolkit/fan_curve.ini +++ /dev/null @@ -1,82 +0,0 @@ -;creator='ppkantorski, B3711' -;show_version=true - -[@fan_curve] -[Fan Info] -;mode=table -;background=false -;spacing=0 -;gap=20 -;header_indent=false -;info_text_color=header -;section_text_color=header -json_file './json/ram_model.json' -'' = 'optimizes the original fancurve for higher clocks' -[$] -;mode=table -;background=false -;header=false -;gap=30 -'->' = 'max tskin limit will be unlocked to 60°C' - - - - -[Tskin Target] -;mode=step_trackbar -;unlocked=true -;min_value=52 -;max_value=60 -;units=°C -set-ini-val /atmosphere/config/system_settings.ini tc use_configurations_on_fwdbg u8!0x1 -set-ini-val /atmosphere/config/system_settings.ini tc tskin_rate_table_console_on_fwdbg 'str!"[[-1000000, 40000, 0, 0], [36000, 43000, 51, 51], [43000, 49000, 51, 128], [49000, {value}000, 128, 255], [{value}000, 1000000, 255, 255]]"' -set-ini-val /atmosphere/config/system_settings.ini tc tskin_rate_table_handheld_on_fwdbg 'str!"[[-1000000, 40000, 0, 0], [36000, 43000, 51, 51], [43000, 49000, 51, 128], [49000, {value}000, 128, 255], [{value}000, 1000000, 255, 255]]"' -set-ini-val /atmosphere/config/system_settings.ini tc holdable_tskin u32!0xEA60 -set-ini-val /atmosphere/config/system_settings.ini tc touchable_tskin u32!0xEA60 - - -[recommended = 54°C] - - - -[Tskin Coefficients] -[V1 - Erista] -;mini=true -set-ini-val /atmosphere/config/system_settings.ini tc tskin_pcb_coefficients_console_on_fwdbg 'str!"[6396, 119440]"' -set-ini-val /atmosphere/config/system_settings.ini tc tskin_pcb_coefficients_handheld_on_fwdbg 'str!"[5817, 129580]"' -set-ini-val /atmosphere/config/system_settings.ini tc tskin_soc_coefficients_console_on_fwdbg 'str!"[6182, 112480]"' -set-ini-val /atmosphere/config/system_settings.ini tc tskin_soc_coefficients_handheld_on_fwdbg 'str!"[5464, 174190]"' - -[V2 - Mariko] -;mini=true -set-ini-val /atmosphere/config/system_settings.ini tc tskin_pcb_coefficients_console_on_fwdbg 'str!"[7338, 112161]"' -set-ini-val /atmosphere/config/system_settings.ini tc tskin_pcb_coefficients_handheld_on_fwdbg 'str!"[6357, 168124]"' -set-ini-val /atmosphere/config/system_settings.ini tc tskin_soc_coefficients_console_on_fwdbg 'str!"[6728, 129810]"' -set-ini-val /atmosphere/config/system_settings.ini tc tskin_soc_coefficients_handheld_on_fwdbg 'str!"[5675, 203453]"' - -[Lite - Mariko] -;mini=true -set-ini-val /atmosphere/config/system_settings.ini tc tskin_pcb_coefficients_console_on_fwdbg 'str!"[7338, 112161]"' -set-ini-val /atmosphere/config/system_settings.ini tc tskin_pcb_coefficients_handheld_on_fwdbg 'str!"[5594, 209601]"' -set-ini-val /atmosphere/config/system_settings.ini tc tskin_soc_coefficients_console_on_fwdbg 'str!"[6728, 129810]"' -set-ini-val /atmosphere/config/system_settings.ini tc tskin_soc_coefficients_handheld_on_fwdbg 'str!"[5235, 199759]"' - -[OLED - Mariko] -;mini=true -set-ini-val /atmosphere/config/system_settings.ini tc tskin_pcb_coefficients_console_on_fwdbg 'str!"[8051, -45213]"' -set-ini-val /atmosphere/config/system_settings.ini tc tskin_pcb_coefficients_handheld_on_fwdbg 'str!"[7176, -33954]"' -set-ini-val /atmosphere/config/system_settings.ini tc tskin_soc_coefficients_console_on_fwdbg 'str!"[7831, 57590]"' -set-ini-val /atmosphere/config/system_settings.ini tc tskin_soc_coefficients_handheld_on_fwdbg 'str!"[9029, 4274]"' - - -[gap] -;mode=table -;background=false -;gap=10 - - -[Restore factory defaults] -remove-ini-section /atmosphere/config/system_settings.ini tc -remove-ini-section './config.ini' 'Tskin Target' -refresh - diff --git a/Ultrahand/OC Toolkit/info.ini b/Ultrahand/OC Toolkit/info.ini deleted file mode 100644 index a2affc64..00000000 --- a/Ultrahand/OC Toolkit/info.ini +++ /dev/null @@ -1,193 +0,0 @@ -;creator=ppkantorski, Souldbminer, MestreYodaRossi, B3711 -;show_version=true - - -[@Presets] -[RAM Table package Info] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -json_file './json/ram_model.json' -'RAM' = '{json_file(0,{ram_model})}' - - -[RAM Table] -;mode=table -;spacing=4 -;gap=0 -hex_file '/atmosphere/kips/loader.kip' -json_file './json/numbers.json' -'Timings' = '({json_file(0,{hex_file(CUST,88,1)})}-{json_file(0,{hex_file(CUST,92,1)})}-{json_file(0,{hex_file(CUST,96,1)})}) {json_file(0,{hex_file(CUST,100,1)})}-{json_file(0,{hex_file(CUST,104,1)})}-{json_file(0,{hex_file(CUST,108,1)})}-{json_file(0,{hex_file(CUST,112,1)})}-{json_file(0,{hex_file(CUST,116,1)})}' - -hex_file '/atmosphere/kips/loader.kip' -json_file './json/dram.json' -'DRAM'= {json_file(0,{hex_file(CUST,64,1)})} -mariko: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{hex_file(CUST,80,3)})} -json_file './json/vddq.json' -'Vddq' = {json_file(0,{hex_file(CUST,72,3)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{hex_file(CUST,68,3)})} -json_file './json/ram_dvb.json' -'EMC DVB' = {json_file(0,{hex_file(CUST,84,1)})} -erista: -json_file './json/max_clocks.json' -'Max Clock' = {json_file(0,{hex_file(CUST,76,3)})} -json_file './json/vdd2.json' -'Vdd2' = {json_file(0,{hex_file(CUST,68,3)})} -json_file './json/ram_dvb.json' -'EMC DVB' = {json_file(0,{hex_file(CUST,84,1)})} - -[gap] -;mode=table -;background=false -;gap=25 - -[CPU Table package Info] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -'CPU' = '{cpu_speedo}' - -[CPU Table] -;mode=table -;spacing=4 -;gap=0 -hex_file '/atmosphere/kips/loader.kip' -json_file './json/numbers.json' -'UV Level' = {json_file(0,{hex_file(CUST,12,1)})} -mariko: -json_file './json/high_freq_uv.json' -'High Freq UV Level' = {json_file(0,{hex_file(CUST,252,1)})} -json_file './json/cpu_table.json' -'Table Config' = {json_file(0,{hex_file(CUST,272,1)})} -json_file './json/mv.json' -'Low Freq Vmin' = {json_file(0,{hex_file(CUST,24,2)})} -'High Freq Vmin' = {json_file(0,{hex_file(CUST,28,2)})} -json_file './json/voltage_limit.json' -'Volt Limit' = {json_file(0,{hex_file(CUST,32,2)})} -json_file './json/max_clocks.json' -'Boost Clock' = {json_file(0,{hex_file(CUST,8,3)})} -json_file './json/cpu_max_clock_m.json' -'Max Clock' = {json_file(0,{hex_file(CUST,264,1)})} -erista: -json_file './json/mv.json' -'Vmin' = {json_file(0,{hex_file(CUST,16,2)})} -json_file './json/voltage_limit.json' -'Volt Limit' = {json_file(0,{hex_file(CUST,20,2)})} -json_file './json/max_clocks.json' -'Boost Clock' = {json_file(0,{hex_file(CUST,8,3)})} - -[gap] -;mode=table -;background=false -;gap=25 - -[GPU Table package Info] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -'GPU' = '{gpu_speedo}' - -[GPU Table] -;mode=table -;spacing=4 -;gap=0 -hex_file '/atmosphere/kips/loader.kip' -mariko: -json_file './json/gpu_uv_m.json' -'UV Level' = {json_file(0,{hex_file(CUST,40,1)})} -ini_file '/config/sys-clk/config.ini' -json_file './json/gpu_dvfs_offset_info.json' -'DVFS' = {json_file(0,{ini_file(values,gpu_dvfs_offset)})} -json_file './json/vmin.json' -'Vmin' = {json_file(0,{hex_file(CUST,56,2)})} -'Vmax' = {json_file(0,{hex_file(CUST,60,2)})} -json_file './json/voltage_offset.json' -'Volt Offset' = {json_file(0,{hex_file(CUST,44,1)})} -erista: -json_file './json/gpu_uv_e.json' -'UV Level' = {json_file(0,{hex_file(CUST,36,1)})} -json_file './json/mv.json' -'Vmin' = {json_file(0,{hex_file(CUST,48,2)})} -json_file './json/voltage_offset.json' -'Volt Offset' = {json_file(0,{hex_file(CUST,44,1)})} -;gap=100 - -[@Custom Table] -[Custom Table] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -hex_file '/atmosphere/kips/loader.kip' -json_file './json/version.json' -'Custom Table' = '{json_file(0,{hex_file(CUST,260,1)})} kip' - -[Custom Table] -;mode=table -;spacing=5 -;gap=24 -hex_file '/atmosphere/kips/loader.kip' -json_file './json/vmin.json' -'76 - 230 MHz' = {json_file(0,{hex_file(CUST,132,2)})} -'307 MHz' = {json_file(0,{hex_file(CUST,136,2)})} -'384 MHz' = {json_file(0,{hex_file(CUST,140,2)})} -'460 MHz' = {json_file(0,{hex_file(CUST,144,2)})} -'537 MHz' = {json_file(0,{hex_file(CUST,148,2)})} -'614 MHz' = {json_file(0,{hex_file(CUST,152,2)})} -'691 MHz' = {json_file(0,{hex_file(CUST,156,2)})} -'768 MHz' = {json_file(0,{hex_file(CUST,160,2)})} -'844 MHz' = {json_file(0,{hex_file(CUST,164,2)})} -'921 MHz' = {json_file(0,{hex_file(CUST,168,2)})} -'998 MHz' = {json_file(0,{hex_file(CUST,172,2)})} -mariko: -'1075 MHz' = {json_file(0,{hex_file(CUST,176,2)})} -'1152 MHz' = {json_file(0,{hex_file(CUST,180,2)})} -'1228 MHz' = {json_file(0,{hex_file(CUST,184,2)})} -'1267 MHz' = {json_file(0,{hex_file(CUST,188,2)})} -'1305 MHz' = {json_file(0,{hex_file(CUST,192,2)})} - - -[Speedos1] -;mode=table -;background=false -;spacing=4 -;gap=15 -;header_indent=true -;info_text_color=header -;section_text_color=header -'Device Info' = ' CPU GPU SOC' - -[Speedos2] -;mode=table -;spacing=4 -;gap=25 -'Speedo' = '{cpu_speedo} | {gpu_speedo} | {soc_speedo}' -mariko: -'IDDQ' = ' {cpu_iddq} | {gpu_iddq} | {soc_iddq}' -erista: -'IDDQ' = ' {cpu_iddq} | {gpu_iddq} | {soc_iddq}' - -[Device Info Table] -;mode=table -;spacing=4 -;gap=15 -'Firmware' = 'HOS {hos_version} | AMS {ams_version}' -'RAM' = '{ram_model}' \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/cpu_max_clock_m.json b/Ultrahand/OC Toolkit/json/cpu_max_clock_m.json deleted file mode 100644 index efd169fa..00000000 --- a/Ultrahand/OC Toolkit/json/cpu_max_clock_m.json +++ /dev/null @@ -1,6 +0,0 @@ -[{ -"02":"1963 MHz", -"00":"2397 MHz", -"03":"2499 MHz", -"01":"2601 MHz" -}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/cpu_max_freq_index.json b/Ultrahand/OC Toolkit/json/cpu_max_freq_index.json deleted file mode 100644 index adf55600..00000000 --- a/Ultrahand/OC Toolkit/json/cpu_max_freq_index.json +++ /dev/null @@ -1,3 +0,0 @@ -[{ -"02":"0", "00":"1", "03":"2", "01":"3" -}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/cpu_table.json b/Ultrahand/OC Toolkit/json/cpu_table.json deleted file mode 100644 index 730816b7..00000000 --- a/Ultrahand/OC Toolkit/json/cpu_table.json +++ /dev/null @@ -1,7 +0,0 @@ -[{ -"00":"Auto", -"01":"Default Table", -"02":"1581 MHz Tbreak", -"03":"Shift Fix 1", -"04":"Shift Fix 2" -}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/dram.json b/Ultrahand/OC Toolkit/json/dram.json deleted file mode 100644 index 2d708272..00000000 --- a/Ultrahand/OC Toolkit/json/dram.json +++ /dev/null @@ -1 +0,0 @@ -[{"00":"AUTO_ADJ", "01":"AUTO_ADJ_HP", "02":"AUTO_ADJ", "03":"NO_ADJ"}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/gpu_dvfs.json b/Ultrahand/OC Toolkit/json/gpu_dvfs.json deleted file mode 100644 index d7ea6924..00000000 --- a/Ultrahand/OC Toolkit/json/gpu_dvfs.json +++ /dev/null @@ -1,14 +0,0 @@ -[ - { - "name": "off", - "dvfs": "0" - }, - { - "name": "official service method", - "dvfs": "1" - }, - { - "name": "hijack method", - "dvfs": "2" - } -] diff --git a/Ultrahand/OC Toolkit/json/gpu_dvfs_offset.json b/Ultrahand/OC Toolkit/json/gpu_dvfs_offset.json deleted file mode 100644 index c1cd3e4a..00000000 --- a/Ultrahand/OC Toolkit/json/gpu_dvfs_offset.json +++ /dev/null @@ -1,27 +0,0 @@ -[ - { "name": "-100 mV", "dvfs": "100" }, - { "name": "-95 mV", "dvfs": "95" }, - { "name": "-90 mV", "dvfs": "90" }, - { "name": "-85 mV", "dvfs": "85" }, - { "name": "-80 mV", "dvfs": "80" }, - { "name": "-75 mV", "dvfs": "75" }, - { "name": "-70 mV", "dvfs": "70" }, - { "name": "-65 mV", "dvfs": "65" }, - { "name": "-60 mV", "dvfs": "60" }, - { "name": "-55 mV", "dvfs": "55" }, - { "name": "-50 mV", "dvfs": "50" }, - { "name": "-45 mV", "dvfs": "45" }, - { "name": "-40 mV", "dvfs": "40" }, - { "name": "-35 mV", "dvfs": "35" }, - { "name": "-30 mV", "dvfs": "30" }, - { "name": "-25 mV", "dvfs": "25" }, - { "name": "-20 mV", "dvfs": "20" }, - { "name": "-15 mV", "dvfs": "15" }, - { "name": "-10 mV", "dvfs": "10" }, - { "name": "-5 mV", "dvfs": "5" }, - { "name": "Auto", "dvfs": "0" }, - { "name": "+5 mV", "dvfs": "-5" }, - { "name": "+10 mV", "dvfs": "-10" }, - { "name": "+15 mV", "dvfs": "-15" }, - { "name": "+20 mV", "dvfs": "-20" } -] diff --git a/Ultrahand/OC Toolkit/json/gpu_dvfs_offset_dec.json b/Ultrahand/OC Toolkit/json/gpu_dvfs_offset_dec.json deleted file mode 100644 index 166a7620..00000000 --- a/Ultrahand/OC Toolkit/json/gpu_dvfs_offset_dec.json +++ /dev/null @@ -1,28 +0,0 @@ -[{ - "100": "100", - "95": "95", - "90": "90", - "85": "85", - "80": "80", - "75": "75", - "70": "70", - "65": "65", - "60": "60", - "55": "55", - "50": "50", - "45": "45", - "40": "40", - "35": "35", - "30": "30", - "25": "25", - "20": "20", - "15": "15", - "10": "10", - "5": "5", - "0": "0", - "-5": "-5", - "-10": "-10", - "-15": "-15", - "-20": "-20", - "null": "0" -}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/gpu_dvfs_offset_index.json b/Ultrahand/OC Toolkit/json/gpu_dvfs_offset_index.json deleted file mode 100644 index 13e37c0a..00000000 --- a/Ultrahand/OC Toolkit/json/gpu_dvfs_offset_index.json +++ /dev/null @@ -1,28 +0,0 @@ -[{ - "100": "0", - "95": "1", - "90": "2", - "85": "3", - "80": "4", - "75": "5", - "70": "6", - "65": "7", - "60": "8", - "55": "9", - "50": "10", - "45": "11", - "40": "12", - "35": "13", - "30": "14", - "25": "15", - "20": "16", - "15": "17", - "10": "18", - "5": "19", - "0": "20", - "-5": "21", - "-10": "22", - "-15": "23", - "-20": "24", - "null": "20" -}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/gpu_dvfs_offset_info.json b/Ultrahand/OC Toolkit/json/gpu_dvfs_offset_info.json deleted file mode 100644 index f80d9713..00000000 --- a/Ultrahand/OC Toolkit/json/gpu_dvfs_offset_info.json +++ /dev/null @@ -1,28 +0,0 @@ -[{ - "100": "-100 mV", - "95": "-95 mV", - "90": "-90 mV", - "85": "-85 mV", - "80": "-80 mV", - "75": "-75 mV", - "70": "-70 mV", - "65": "-65 mV", - "60": "-60 mV", - "55": "-55 mV", - "50": "-50 mV", - "45": "-45 mV", - "40": "-40 mV", - "35": "-35 mV", - "30": "-30 mV", - "25": "-25 mV", - "20": "-20 mV", - "15": "-15 mV", - "10": "-10 mV", - "5": "-5 mV", - "0": "Auto", - "-5": "+5 mV", - "-10": "+10 mV", - "-15": "+15 mV", - "-20": "+20 mV", - "null": "Auto" -}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/gpu_uv_e.json b/Ultrahand/OC Toolkit/json/gpu_uv_e.json deleted file mode 100644 index be9e570f..00000000 --- a/Ultrahand/OC Toolkit/json/gpu_uv_e.json +++ /dev/null @@ -1,8 +0,0 @@ -[ -{ -"00":"0 - Default Table", -"01": "1 - M static +30mV", -"02": "2 - high UV table", -"03": "3 - Custom static" -} -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/gpu_uv_m.json b/Ultrahand/OC Toolkit/json/gpu_uv_m.json deleted file mode 100644 index 18e28cda..00000000 --- a/Ultrahand/OC Toolkit/json/gpu_uv_m.json +++ /dev/null @@ -1,8 +0,0 @@ -[ -{ -"00":"0 - HiOPT", -"01": "1 - HiOPT -15mV(2)", -"02": "2 - high UV table", -"03": "3 - Custom static" -} -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/high_freq_uv.json b/Ultrahand/OC Toolkit/json/high_freq_uv.json deleted file mode 100644 index ee462524..00000000 --- a/Ultrahand/OC Toolkit/json/high_freq_uv.json +++ /dev/null @@ -1 +0,0 @@ -[{"00":"↑", "01":"1", "02":"2", "03":"3", "04":"4", "05":"5", "06":"6", "07":"7", "08":"8", "09":"9", "0A":"10", "0B":"11", "0C":"12"}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/keys.json b/Ultrahand/OC Toolkit/json/keys.json deleted file mode 100644 index 6ea7a941..00000000 --- a/Ultrahand/OC Toolkit/json/keys.json +++ /dev/null @@ -1,26 +0,0 @@ -[ - { - "name": "L+R+DUP", - "value": "L+R+DUP" - }, - { - "name": "L+R+DDOWN", - "value": "L+R+DDOWN" - }, - { - "name": "ZL+ZR+DUP", - "value": "ZL+ZR+DUP" - }, - { - "name": "ZL+ZR+DDOWN", - "value": "ZL+ZR+DDOWN" - }, - { - "name": "PLUS+MINUS", - "value": "PLUS+MINUS" - }, - { - "name": "L+DDOWN+RS", - "value": "L+DDOWN+RSTICK" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/keys_b.json b/Ultrahand/OC Toolkit/json/keys_b.json deleted file mode 100644 index 02eba9fc..00000000 --- a/Ultrahand/OC Toolkit/json/keys_b.json +++ /dev/null @@ -1,10 +0,0 @@ -[ - { - "L+R+DUP": "L+R+DUP", - "L+R+DDOWN": "L+R+DDOWN", - "ZL+ZR+DUP": "ZL+ZR+DUP", - "ZL+ZR+DDOWN": "ZL+ZR+DDOWN", - "PLUS+MINUS": "PLUS+MINUS", - "L+DDOWN+RSTICK": "L+DDOWN+RS" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/max_clocks.json b/Ultrahand/OC Toolkit/json/max_clocks.json deleted file mode 100644 index ebfc98d3..00000000 --- a/Ultrahand/OC Toolkit/json/max_clocks.json +++ /dev/null @@ -1 +0,0 @@ -[{"006B1C":"1862 MHz", "00B61C":"1881 MHz", "00011D":"1900 MHz", "004C1D":"1920 MHz", "00971D":"1939 MHz", "00E21D":"1958 MHz", "002D1E":"1977 MHz", "00781E":"1996 MHz", "00C31E":"2016 MHz", "000E1F":"2035 MHz", "00591F":"2054 MHz", "00A41F":"2073 MHz", "00EF1F":"2092 MHz", "003A20":"2112 MHz", "008520":"2131 MHz", "00D020":"2150 MHz", "001B21":"2169 MHz", "006621":"2188 MHz", "00B121":"2208 MHz", "00FC21":"2227 MHz", "004722":"2246 MHz", "009222":"2265 MHz", "00DD22":"2284 MHz", "002823":"2304 MHz", "007323":"2323 MHz", "00BE23":"2342 MHz", "000924":"2361 MHz", "005424":"2380 MHz", "006A18":"1600 MHz", "E8EA18":"1633 MHz", "D06B19":"1666 MHz", "A0F019":"1700 MHz", "88711A":"1733 MHz", "70F21A":"1766 MHz", "40771B":"1800 MHz", "28F81B":"1833 MHz", "10791C":"1866 MHz", "E0FD1C":"1900 MHz", "C87E1D":"1933 MHz", "B0FF1D":"1966 MHz", "80841E":"2000 MHz", "68051F":"2033 MHz", "50861F":"2066 MHz", "200B20":"2100 MHz", "088C20":"2133 MHz", "F00C21":"2166 MHz", "C09121":"2200 MHz", "A81222":"2233 MHz", "909322":"2266 MHz", "601823":"2300 MHz", "489923":"2333 MHz", "301A24":"2366 MHz", "009F24":"2400 MHz", "E81F25":"2433 MHz", "D0A025":"2466 MHz", "A02526":"2500 MHz", "88A626":"2533 MHz", "702727":"2566 MHz", "40AC27":"2600 MHz", "282D28":"2633 MHz", "10AE28":"2666 MHz", "E03229":"2700 MHz", "C8B329":"2733 MHz", "B0342A":"2766 MHz", "80B92A":"2800 MHz", "683A2B":"2833 MHz", "50BB2B":"2866 MHz", "20402C":"2900 MHz", "08C12C":"2933 MHz", "F0412D":"2966 MHz", "C0C62D":"3000 MHz", "A8472E":"3033 MHz", "90C82E":"3066 MHz", "604D2F":"3100 MHz", "48CE2F":"3133 MHz", "304F30":"3166 MHz", "00D430":"3200 MHz", "A83C1B":"1785 MHz", "18CB1C":"1887 MHz", "F8F31D":"1963 MHz", "F8E71F":"2091 MHz", "687621":"2193 MHz", "D80423":"2295 MHz", "489324":"2397 MHz", "B82126":"2499 MHz", "28B027":"2601 MHz", "983E29":"2703 MHz"}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/mv.json b/Ultrahand/OC Toolkit/json/mv.json deleted file mode 100644 index 9ccfd4f1..00000000 --- a/Ultrahand/OC Toolkit/json/mv.json +++ /dev/null @@ -1 +0,0 @@ -[{"0000":"Do not override", "E001": "480mV", "E501": "485mV", "EA01": "490mV", "EF01": "495mV", "F401":"500 mV", "F901":"505 mV", "FE01":"510 mV", "0302":"515 mV", "0802":"520 mV", "0D02":"525 mV", "1202":"530 mV", "1702":"535 mV", "1C02":"540 mV", "2102":"545 mV", "2602":"550 mV", "2B02":"555 mV", "3002":"560 mV", "3502":"565 mV", "3A02":"570 mV", "3F02":"575 mV", "4402":"580 mV", "4902":"585 mV", "4E02":"590 mV", "5302":"595 mV", "5802":"600 mV", "5D02":"605 mV", "6202":"610 mV", "6702":"615 mV", "6C02":"620 mV", "7102":"625 mV", "7602":"630 mV", "7B02":"635 mV", "8002":"640 mV", "8502":"645 mV", "8A02":"650 mV", "8F02":"655 mV", "9402":"660 mV", "9902":"665 mV", "9E02":"670 mV", "A302":"675 mV", "A802":"680 mV", "AD02":"685 mV", "B202":"690 mV", "B702":"695 mV", "BC02":"700 mV", "C102":"705 mV", "C602":"710 mV", "CB02":"715 mV", "D002":"720 mV", "D502":"725 mV", "DA02":"730 mV", "DF02":"735 mV", "E402":"740 mV", "E902":"745 mV", "EE02":"750 mV", "F302":"755 mV", "F802":"760 mV", "FD02":"765 mV", "0203":"770 mV", "0703":"775 mV", "0C03":"780 mV", "1103":"785 mV", "1603":"790 mV", "1B03":"795 mV", "2003":"800 mV", "2503":"805 mV", "2A03":"810 mV", "2F03":"815 mV", "3403":"820 mV", "3903":"825 mV", "3E03":"830 mV", "4303":"835 mV", "4803":"840 mV", "5203":"850 mV", "4D03":"845 mV", "5203":"850 mV", "5703":"855 mV", "5C03":"860 mV", "6103":"865 mV", "6603":"870 mV", "6B03":"875 mV", "7003":"880 mV", "7503":"885 mV", "7A03":"890 mV", "7F03":"895 mV", "8403":"900 mV", "8903":"905 mV", "8E03":"910 mV", "9303":"915 mV", "9803":"920 mV", "9D03":"925 mV", "A203":"930 mV", "A703":"935 mV", "AC03":"940 mV", "B103":"945 mV", "B603":"950 mV", "BB03":"955 mV", "C003":"960 mV", "C503":"965 mV", "CA03":"970 mV", "CF03":"975 mV", "D403":"980 mV", "D903":"985 mV", "DE03":"990 mV", "E303":"995 mV", "E803":"1000 mV"}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/numbers.json b/Ultrahand/OC Toolkit/json/numbers.json deleted file mode 100644 index eff37b0f..00000000 --- a/Ultrahand/OC Toolkit/json/numbers.json +++ /dev/null @@ -1 +0,0 @@ -[{"00":"0", "01":"1", "02":"2", "03":"3", "04":"4", "05":"5", "06":"6", "07":"7", "08":"8", "09":"9", "0A":"10", "0B":"11", "0C":"12", "0D":"13", "0E":"14", "0F":"15", "10":"16", "11":"17", "12":"18", "13":"19", "14":"20", "15":"21", "16":"22", "17":"23", "18":"24", "19":"25", "1A":"26", "1B":"27", "1C":"28", "1D":"29", "1E":"30", "1F":"31", "20":"32", "21":"33", "22":"34", "23":"35", "24":"36", "25":"37", "26":"38", "27":"39", "28":"40", "29":"41", "2A":"42"}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/ram_dvb.json b/Ultrahand/OC Toolkit/json/ram_dvb.json deleted file mode 100644 index 64793161..00000000 --- a/Ultrahand/OC Toolkit/json/ram_dvb.json +++ /dev/null @@ -1 +0,0 @@ -[{"FDFFFFFF":"-3", "FEFFFFFF":"-2", "FFFFFFFF":"-1", "00000000":"0", "01000000":"1", "02000000":"2", "03000000":"3", "04000000":"4", "05000000":"5", "FD":"-3", "FE":"-2", "FF":"-1", "00":"0", "01":"1", "02":"2", "03":"3", "04":"4", "05":"5"}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/ram_dvb_index.json b/Ultrahand/OC Toolkit/json/ram_dvb_index.json deleted file mode 100644 index 38951bb3..00000000 --- a/Ultrahand/OC Toolkit/json/ram_dvb_index.json +++ /dev/null @@ -1,3 +0,0 @@ -[ -{"FE":"0", "FF":"1", "00":"2", "01":"3", "02":"4", "03":"5", "04":"6", "05":"7"} -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/ram_model.json b/Ultrahand/OC Toolkit/json/ram_model.json deleted file mode 100644 index 27e8ba38..00000000 --- a/Ultrahand/OC Toolkit/json/ram_model.json +++ /dev/null @@ -1,23 +0,0 @@ -[ -{ -"K4U6E3S4AA-MGCL":"AA-MGCL", -"K4U6E3S4AM-MGCJ":"AM-MGCJ", -"K4U6E3S4AB-MGCL":"AB-MGCL", -"K4F6E304HB-MGCH":"HB-MGCH", -"K4UBE3D4AA-MGCL":"AA-MGCL 8GB", -"K4UBE3D4AM-MGCJ":"AM-MGCJ 8GB", -"K4FBE3D4HM-MGXX":"HM-MGXX 8GB", - -"MT53E512M32D2NP-046 WT:F":"WT:F", -"MT53E512M32D2NP-046 WT:E":"WT:E", -"MT53E512M32D1NP-046 WT:B":"WT:B", -"MT53B512M32D2NP-062 WT:C":"WT:C", -"MT53E512M32D1ZW-046 AUT:B":"AUT:B", - -"H9HCNNNBKMMLHR-NME":"NME", -"H9HCNNNBKMMLXR-NEE":"NEE", -"H9HCNNNBPUMLHR-NLE":"NLE", - -"H54G46CYRBX267":"CYRBX267" -} -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/speedo.json b/Ultrahand/OC Toolkit/json/speedo.json deleted file mode 100644 index d1c905b0..00000000 --- a/Ultrahand/OC Toolkit/json/speedo.json +++ /dev/null @@ -1,67 +0,0 @@ -[{ -"C805":"1480", "C806":"1481", "C807":"1482", "C808":"1483", "C809":"1484", - "CD05":"1485", "CD06":"1486", "CD07":"1487", "CD08":"1488", "CD09":"1489", - "D205":"1490", "D206":"1491", "D207":"1492", "D208":"1493", "D209":"1494", - "D705":"1495", "D706":"1496", "D707":"1497", "D708":"1498", "D709":"1499", - "DC05":"1500", "DC06":"1501", "DC07":"1502", "DC08":"1503", "DC09":"1504", - "E105":"1505", "E106":"1506", "E107":"1507", "E108":"1508", "E109":"1509", - "E605":"1510", "E606":"1511", "E607":"1512", "E608":"1513", "E609":"1514", - "EB05":"1515", "EB06":"1516", "EB07":"1517", "EB08":"1518", "EB09":"1519", - "F005":"1520", "F006":"1521", "F007":"1522", "F008":"1523", "F009":"1524", - "F505":"1525", "F506":"1526", "F507":"1527", "F508":"1528", "F509":"1529", - "FA05":"1530", "FA06":"1531", "FA07":"1532", "FA08":"1533", "FA09":"1534", - "FF05":"1535", "FF06":"1536", "FF07":"1537", "FF08":"1538", "FF09":"1539", - "0406":"1540", "0407":"1541", "0408":"1542", "0409":"1543", "040A":"1544", - "0906":"1545", "0907":"1546", "0908":"1547", "0909":"1548", "090A":"1549", - "0E06":"1550", "0E07":"1551", "0E08":"1552", "0E09":"1553", "0E0A":"1554", - "1306":"1555", "1307":"1556", "1308":"1557", "1309":"1558", "130A":"1559", - "1806":"1560", "1807":"1561", "1808":"1562", "1809":"1563", "180A":"1564", - "1D06":"1565", "1D07":"1566", "1D08":"1567", "1D09":"1568", "1D0A":"1569", - "2206":"1570", "2207":"1571", "2208":"1572", "2209":"1573", "220A":"1574", - "2706":"1575", "2707":"1576", "2708":"1577", "2709":"1578", "270A":"1579", - "2C06":"1580", "2C07":"1581", "2C08":"1582", "2C09":"1583", "2C0A":"1584", - "3106":"1585", "3107":"1586", "3108":"1587", "3109":"1588", "310A":"1589", - "3606":"1590", "3607":"1591", "3608":"1592", "3609":"1593", "360A":"1594", - "3B06":"1595", "3B07":"1596", "3B08":"1597", "3B09":"1598", "3B0A":"1599", - "4006":"1600", "4007":"1601", "4008":"1602", "4009":"1603", "400A":"1604", - "4506":"1605", "4507":"1606", "4508":"1607", "4509":"1608", "450A":"1609", - "4A06":"1610", "4A07":"1611", "4A08":"1612", "4A09":"1613", "4A0A":"1614", - "4F06":"1615", "4F07":"1616", "4F08":"1617", "4F09":"1618", "4F0A":"1619", - "5406":"1620", "5407":"1621", "5408":"1622", "5409":"1623", "540A":"1624", - "5906":"1625", "5907":"1626", "5908":"1627", "5909":"1628", "590A":"1629", - "5E06":"1630", "5E07":"1631", "5E08":"1632", "5E09":"1633", "5E0A":"1634", - "6306":"1635", "6307":"1636", "6308":"1637", "6309":"1638", "630A":"1639", - "6806":"1640", "6807":"1641", "6808":"1642", "6809":"1643", "680A":"1644", - "6D06":"1645", "6D07":"1646", "6D08":"1647", "6D09":"1648", "6D0A":"1649", - "7206":"1650", "7207":"1651", "7208":"1652", "7209":"1653", "720A":"1654", - "7706":"1655", "7707":"1656", "7708":"1657", "7709":"1658", "770A":"1659", - "7C06":"1660", "7C07":"1661", "7C08":"1662", "7C09":"1663", "7C0A":"1664", - "8106":"1665", "8107":"1666", "8108":"1667", "8109":"1668", "810A":"1669", - "8606":"1670", "8607":"1671", "8608":"1672", "8609":"1673", "860A":"1674", - "8B06":"1675", "8B07":"1676", "8B08":"1677", "8B09":"1678", "8B0A":"1679", - "9006":"1680", "9007":"1681", "9008":"1682", "9009":"1683", "900A":"1684", - "9506":"1685", "9507":"1686", "9508":"1687", "9509":"1688", "950A":"1689", - "9A06":"1690", "9A07":"1691", "9A08":"1692", "9A09":"1693", "9A0A":"1694", - "9F06":"1695", "9F07":"1696", "9F08":"1697", "9F09":"1698", "9F0A":"1699", - "A406":"1700", "A407":"1701", "A408":"1702", "A409":"1703", "A40A":"1704", - "A906":"1705", "A907":"1706", "A908":"1707", "A909":"1708", "A90A":"1709", - "AE06":"1710", "AE07":"1711", "AE08":"1712", "AE09":"1713", "AE0A":"1714", - "B306":"1715", "B307":"1716", "B308":"1717", "B309":"1718", "B30A":"1719", - "B806":"1720", "B807":"1721", "B808":"1722", "B809":"1723", "B80A":"1724", - "BD06":"1725", "BD07":"1726", "BD08":"1727", "BD09":"1728", "BD0A":"1729", - "C206":"1730", "C207":"1731", "C208":"1732", "C209":"1733", "C20A":"1734", - "C706":"1735", "C707":"1736", "C708":"1737", "C709":"1738", "C70A":"1739", - "CC06":"1740", "CC07":"1741", "CC08":"1742", "CC09":"1743", "CC0A":"1744", - "D106":"1745", "D107":"1746", "D108":"1747", "D109":"1748", "D10A":"1749", - "D606":"1750", "D607":"1751", "D608":"1752", "D609":"1753", "D60A":"1754", - "DB06":"1755", "DB07":"1756", "DB08":"1757", "DB09":"1758", "DB0A":"1759", - "E006":"1760", "E007":"1761", "E008":"1762", "E009":"1763", "E00A":"1764", - "E506":"1765", "E507":"1766", "E508":"1767", "E509":"1768", "E50A":"1769", - "EA06":"1770", "EA07":"1771", "EA08":"1772", "EA09":"1773", "EA0A":"1774", - "EF06":"1775", "EF07":"1776", "EF08":"1777", "EF09":"1778", "EF0A":"1779", - "F406":"1780", "F407":"1781", "F408":"1782", "F409":"1783", "F40A":"1784", - "F906":"1785", "F907":"1786", "F908":"1787", "F909":"1788", "F90A":"1789", - "FE06":"1790", "FE07":"1791", "FE08":"1792", "FE09":"1793", "FE0A":"1794", - "0307":"1795", "0308":"1796", "0309":"1797", "030A":"1798", "030B":"1799", - "0807":"1800" -}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/vdd2.json b/Ultrahand/OC Toolkit/json/vdd2.json deleted file mode 100644 index 71e9077d..00000000 --- a/Ultrahand/OC Toolkit/json/vdd2.json +++ /dev/null @@ -1 +0,0 @@ -[{"000000":"Do not override", "74EC0D":"912.5 mV", "481D0E":"925 mV", "1C4E0E":"937.5 mV", "F07E0E":"950 mV", "C4AF0E":"962.5 mV", "98E00E":"975 mV", "6CZZ0F":"987.5 mV", "40420F":"1000 mV", "14730F":"1012.5 mV", "E8A30F":"1025 mV", "BCD40F":"1037.5 mV", "900510":"1050 mV", "643610":"1062.5 mV", "386710":"1075 mV", "0C9810":"1087.5 mV", "E0C810":"1100 mV", "B4F910":"1112.5 mV", "882A11":"1125 mV", "5C5B11":"1137.5 mV", "308C11":"1150 mV", "04BD11":"1162.5 mV", "D8ED11":"1175 mV", "AC1E12":"1187.5 mV", "804F12":"1200 mV", "548012":"1212.5 mV", "28B112":"1225 mV", "FCE112":"1237.5 mV", "D01213":"1250 mV", "A44313":"1262.5 mV", "787413":"1275 mV", "4CA513":"1287.5 mV", "20D613":"1300 mV", "F40614":"1312.5 mV", "C83714":"1325 mV", "9C6814":"1337.5 mV", "709914":"1350 mV", "44CA14": "1362.5 mV", "18FB14": "1375 mV", "EC2B15": "1387.5 mV", "C05C15": "1400 mV"}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/vddq.json b/Ultrahand/OC Toolkit/json/vddq.json deleted file mode 100644 index a7a28fab..00000000 --- a/Ultrahand/OC Toolkit/json/vddq.json +++ /dev/null @@ -1 +0,0 @@ -[{"000000":"Do not override", "50A505":"370 mV", "D8B805":"375 mV", "60CC05":"380 mV", "E8DF05":"385 mV", "70F305":"390 mV", "F80606":"395 mV", "801A06":"400 mV", "082E06":"405 mV", "904106":"410 mV", "185506":"415 mV", "A06806":"420 mV", "287C06":"425 mV", "B08F06":"430 mV", "38A306":"435 mV", "C0B606":"440 mV", "48CA06":"445 mV", "D0DD06":"450 mV", "58F106":"455 mV", "E00407":"460 mV", "681807":"465 mV", "F02B07":"470 mV", "783F07":"475 mV", "005307":"480 mV", "886607":"485 mV", "107A07":"490 mV", "988D07":"495 mV", "20A107":"500 mV", "A8B407":"505 mV", "30C807":"510 mV", "B8DB07":"515 mV", "40EF07":"520 mV", "C80208":"525 mV", "501608":"530 mV", "D82908":"535 mV", "603D08":"540 mV", "E85008":"545 mV", "706408":"550 mV", "F87708":"555 mV", "808B08":"560 mV", "089F08":"565 mV", "90B208":"570 mV", "18C608":"575 mV", "A0D908":"580 mV", "28ED08":"585 mV", "B00009":"590 mV", "381409":"595 mV", "C02709":"600 mV", "483B09":"605 mV", "D04E09":"610 mV", "586209":"615 mV", "E07509":"620 mV", "688909":"625 mV", "F09C09":"630 mV", "78B009":"635 mV", "00C409":"640 mV", "88D709":"645 mV", "10EB09":"650 mV", "98FE09":"655 mV", "20120A":"660 mV", "A8250A":"665 mV", "30390A":"670 mV", "B84C0A":"675 mV", "40600A":"680 mV", "C8730A":"685 mV", "50870A":"690 mV", "D89A0A":"695 mV", "60AE0A":"700 mV"}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/version.json b/Ultrahand/OC Toolkit/json/version.json deleted file mode 100644 index 88001598..00000000 --- a/Ultrahand/OC Toolkit/json/version.json +++ /dev/null @@ -1,26 +0,0 @@ -[ -{ -"00":"?", -"2C":"1.3.2 or lower", -"2D":"1.3.3", -"2E":"1.3.4", -"2F":"1.3.5", -"30":"1.3.6", -"31":"1.3.7", -"32":"1.4.0", -"33":"1.4.1", -"34":"1.4.2", -"35":"1.4.3", -"36":"1.4.4", -"37":"1.5.0", -"38":"1.5.1", -"39":"1.6.0", -"3A":"1.6.1", -"3B":"1.6.2", -"3C":"1.6.3", -"3D":"1.6.4", -"3E":"1.6.5", -"3F":"1.6.6", -"40":"1.6.7" -} -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/vmin.json b/Ultrahand/OC Toolkit/json/vmin.json deleted file mode 100644 index 15b89704..00000000 --- a/Ultrahand/OC Toolkit/json/vmin.json +++ /dev/null @@ -1 +0,0 @@ -[{"0000":"Auto", "E001": "480 mV", "E501": "485 mV", "EA01": "490 mV", "EF01": "495 mV", "F401":"500 mV", "F901":"505 mV", "FE01":"510 mV", "0302":"515 mV", "0802":"520 mV", "0D02":"525 mV", "1202":"530 mV", "1702":"535 mV", "1C02":"540 mV", "2102":"545 mV", "2602":"550 mV", "2B02":"555 mV", "3002":"560 mV", "3502":"565 mV", "3A02":"570 mV", "3F02":"575 mV", "4402":"580 mV", "4902":"585 mV", "4E02":"590 mV", "5302":"595 mV", "5802":"600 mV", "5D02":"605 mV", "6202":"610 mV", "6702":"615 mV", "6C02":"620 mV", "7102":"625 mV", "7602":"630 mV", "7B02":"635 mV", "8002":"640 mV", "8502":"645 mV", "8A02":"650 mV", "8F02":"655 mV", "9402":"660 mV", "9902":"665 mV", "9E02":"670 mV", "A302":"675 mV", "A802":"680 mV", "AD02":"685 mV", "B202":"690 mV", "B702":"695 mV", "BC02":"700 mV", "C102":"705 mV", "C602":"710 mV", "CB02":"715 mV", "D002":"720 mV", "D502":"725 mV", "DA02":"730 mV", "DF02":"735 mV", "E402":"740 mV", "E902":"745 mV", "EE02":"750 mV", "F302":"755 mV", "F802":"760 mV", "FD02":"765 mV", "0203":"770 mV", "0703":"775 mV", "0C03":"780 mV", "1103":"785 mV", "1603":"790 mV", "1B03":"795 mV", "2003":"800 mV", "2503":"805 mV", "2A03":"810 mV", "2F03":"815 mV", "3403":"820 mV", "3903":"825 mV", "3E03":"830 mV", "4303":"835 mV", "4803":"840 mV", "5203":"850 mV", "4D03":"845 mV", "5203":"850 mV", "5703": "855 mV", "5C03": "860 mV", "6103": "865 mV", "6603": "870 mV", "6B03": "875 mV", "7003": "880 mV", "7503": "885 mV", "7A03": "890 mV", "7F03": "895 mV", "8403": "900 mV", "8903": "905 mV", "8E03": "910 mV", "9303": "915 mV", "9803": "920 mV", "9D03": "925 mV", "A203": "930 mV", "A703": "935 mV", "AC03": "940 mV", "B103": "945 mV", "B603": "950 mV", "BB03": "955 mV", "C003": "960 mV", "C503":"965 mV", "CA03":"970 mV", "CF03":"975 mV", "D403":"980 mV", "D903":"985 mV", "DE03":"990 mV", "E303":"995 mV", "E803": "disabled", "D007": "disabled"}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/vmin_dec.json b/Ultrahand/OC Toolkit/json/vmin_dec.json deleted file mode 100644 index aa924c2a..00000000 --- a/Ultrahand/OC Toolkit/json/vmin_dec.json +++ /dev/null @@ -1 +0,0 @@ -[{"null":"Auto", "480":"480 mV", "485":"485 mV", "490":"490 mV", "495":"495 mV", "500":"500 mV", "505":"505 mV", "510":"510 mV", "515":"515 mV", "520":"520 mV", "525":"525 mV", "530":"530 mV", "535":"535 mV", "540":"540 mV", "545":"545 mV", "550":"550 mV", "555":"555 mV", "560":"560 mV", "565":"565 mV", "570":"570 mV", "575":"575 mV", "580":"580 mV", "585":"585 mV", "590":"590 mV", "595":"595 mV", "600":"600 mV", "605":"605 mV", "610":"610 mV", "615":"615 mV", "620":"620 mV", "625":"625 mV", "630":"630 mV", "635":"635 mV", "640":"640 mV", "645":"645 mV", "650":"650 mV", "655":"655 mV", "660":"660 mV", "665":"665 mV", "670":"670 mV", "675":"675 mV", "680":"680 mV", "685":"685 mV", "690":"690 mV", "695":"695 mV", "700":"700 mV", "705":"705 mV", "710":"710 mV", "715":"715 mV", "720":"720 mV", "725":"725 mV", "730":"730 mV", "735":"735 mV", "740":"740 mV", "745":"745 mV", "750":"750 mV", "755":"755 mV", "760":"760 mV", "765":"765 mV", "770":"770 mV", "775":"775 mV", "780":"780 mV", "785":"785 mV", "790":"790 mV", "795":"795 mV", "800":"800 mV", "805":"805 mV", "810":"810 mV", "815":"815 mV", "820":"820 mV", "825":"825 mV", "830":"830 mV", "835":"835 mV", "840":"840 mV", "845":"845 mV", "850":"850 mV", "855":"855 mV", "860":"860 mV", "865":"865 mV", "870":"870 mV", "875":"875 mV", "880":"880 mV", "885":"885 mV", "890":"890 mV", "895":"895 mV", "900":"900 mV", "905":"905 mV", "910":"910 mV", "915":"915 mV", "920":"920 mV", "925":"925 mV", "930":"930 mV", "935":"935 mV", "940":"940 mV", "945":"945 mV", "950":"950 mV", "955":"955 mV", "960":"960 mV", "965":"965 mV", "970":"970 mV", "975":"975 mV", "980":"980 mV", "985":"985 mV", "990":"990"}] diff --git a/Ultrahand/OC Toolkit/json/voltage_limit.json b/Ultrahand/OC Toolkit/json/voltage_limit.json deleted file mode 100644 index 36192b75..00000000 --- a/Ultrahand/OC Toolkit/json/voltage_limit.json +++ /dev/null @@ -1 +0,0 @@ -[{"2003":"800 mV", "2503":"805 mV", "2A03":"810 mV", "2F03":"815 mV", "3403":"820 mV", "3903":"825 mV", "3E03":"830 mV", "4303":"835 mV", "4803":"840 mV", "4D03":"845 mV", "5203":"850 mV", "5703":"855 mV", "5C03":"860 mV", "6103":"865 mV", "6603":"870 mV", "6B03":"875 mV", "7003":"880 mV", "7503":"885 mV", "7A03":"890 mV", "7F03":"895 mV", "8403":"900 mV", "8903":"905 mV", "8E03":"910 mV", "9303":"915 mV", "9803":"920 mV", "9D03":"925 mV", "A203":"930 mV", "A703":"935 mV", "AC03":"940 mV", "B103":"945 mV", "B603":"950 mV", "BB03":"955 mV", "C003":"960 mV", "C503":"965 mV", "CA03":"970 mV", "CF03":"975 mV", "D403":"980 mV", "D903":"985 mV", "DE03":"990 mV", "E303":"995 mV", "E803":"1000 mV", "ED03":"1005 mV", "F203":"1010 mV", "F703":"1015 mV", "FC03":"1020 mV", "0104":"1025 mV", "0304":"1030 mV", "0B04":"1035 mV", "1004":"1040 mV", "1504":"1045 mV", "1A04":"1050 mV", "1F04":"1055 mV", "2404":"1060 mV", "2904":"1065 mV", "2E04":"1070 mV", "3304":"1075 mV", "3804":"1080 mV", "3D04":"1085 mV", "4204":"1090 mV", "4704":"1095 mV", "4C04":"1100 mV", "5104":"1105 mV", "5604":"1110 mV", "5B04":"1115 mV", "6004":"1120 mV", "6504":"1125 mV", "6A04":"1130 mV", "6F04":"1135 mV", "7404":"1140 mV", "7904":"1145 mV", "7E04":"1150 mV", "8304":"1155 mV", "8804":"1160 mV", "8D04":"1165 mV", "9204":"1170 mV", "9704":"1175 mV", "9C04":"1180 mV", "A104":"1185 mV", "A604":"1190 mV", "AB04":"1195 mV", "B004":"1200 mV", "B504":"1205 mV", "BA04":"1210 mV", "BF04":"1215 mV", "C404":"1220 mV", "C904":"1225 mV", "CE04":"1230 mV", "D304":"1235 mV", "D804":"1240 mV", "DD04":"1245 mV", "E204":"1250 mV", "E704":"1255 mV", "EC04":"1260 mV", "F104":"1265 mV", "F604":"1270 mV", "FB04":"1275 mV", "0005":"1280 mV", "0505":"1285 mV", "0A05":"1290 mV", "0F05":"1295 mV", "1405":"1300 mV", "E904":"1257 mV", "CB04":"1227 mV"}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/voltage_offset.json b/Ultrahand/OC Toolkit/json/voltage_offset.json deleted file mode 100644 index 14396a2b..00000000 --- a/Ultrahand/OC Toolkit/json/voltage_offset.json +++ /dev/null @@ -1 +0,0 @@ -[{"00":"0 mV", "05":"-5 mV", "0A":"-10 mV", "0F":"-15 mV", "14":"-20 mV", "19":"-25 mV", "1E":"-30 mV", "23":"-35 mV", "28":"-40 mV", "2D":"-45 mV", "32":"-50 mV", "37":"-55 mV", "3C":"-60 mV", "41":"-65 mV", "46":"-70 mV", "4B":"-75 mV", "50":"-80 mV", "55":"-85 mV", "5A":"-90 mV", "5F":"-95 mV", "64":"-100 mV", "69":"-105 mV", "6E":"-110 mV", "73":"-115 mV", "78":"-120 mV", "7D":"-125 mV", "82":"-130 mV", "87":"-135 mV", "8C":"-140 mV", "91":"-145 mV", "96":"-150 mV", "9B":"-155 mV", "A0":"-160 mV", "A5":"-165 mV", "AA":"-170 mV", "AF":"-175 mV", "B4":"-180 mV", "B9":"-185 mV", "BE":"-190 mV", "C3":"-195 mV", "C8":"-200 mV"}] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/json/voltage_offset_index.json b/Ultrahand/OC Toolkit/json/voltage_offset_index.json deleted file mode 100644 index 8147a0ff..00000000 --- a/Ultrahand/OC Toolkit/json/voltage_offset_index.json +++ /dev/null @@ -1,3 +0,0 @@ -[ -{"00":"0", "05":"1", "0A":"2", "0F":"3", "14":"4", "19":"5", "1E":"6", "23":"7", "28":"8", "2D":"9", "32":"10", "37":"11", "3C":"12", "41":"13", "46":"14", "4B":"15", "50":"16", "55":"17", "5A":"18", "5F":"19", "64":"20", "69":"21", "6E":"22", "73":"23", "78":"24", "7D":"25", "82":"26", "87":"27", "8C":"28", "91":"29", "96":"30", "9B":"31", "A0":"32", "A5":"33", "AA":"34", "AF":"35", "B4":"36", "B9":"37", "BE":"38", "C3":"39", "C8":"40"} -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/mariko/cpu_boost_clock.json b/Ultrahand/OC Toolkit/mariko/cpu_boost_clock.json deleted file mode 100644 index 9fb787d2..00000000 --- a/Ultrahand/OC Toolkit/mariko/cpu_boost_clock.json +++ /dev/null @@ -1,47 +0,0 @@ -[ - { - "name": "1785 MHz", - "label": "1785 MHz - default", - "hex": "A83C1B" - }, - { - "name": "1887 MHz", - "label": "1887 MHz", - "hex": "18CB1C" - }, - { - "name": "1963 MHz", - "label": "1963 MHz", - "hex": "F8F31D" - }, - { - "name": "2091 MHz", - "label": "2091 MHz", - "hex": "F8E71F" - }, - { - "name": "2193 MHz", - "label": "2193 MHz", - "hex": "687621" - }, - { - "name": "2295 MHz", - "label": "2295 MHz", - "hex": "D80423" - }, - { - "name": "2397 MHz", - "label": "2397 MHz", - "hex": "489324" - }, - { - "name": "2499 MHz", - "label": "2499 MHz", - "hex": "B82126" - }, - { - "name": "2601 MHz", - "label": "2601 MHz", - "hex": "28B027" - } -] diff --git a/Ultrahand/OC Toolkit/mariko/cpu_high_uv.json b/Ultrahand/OC Toolkit/mariko/cpu_high_uv.json deleted file mode 100644 index 69a6f983..00000000 --- a/Ultrahand/OC Toolkit/mariko/cpu_high_uv.json +++ /dev/null @@ -1,67 +0,0 @@ -[ - { - "name": " ↑", - "label": "↑", - "hex": "00" - }, - { - "name": " 1", - "label": "1", - "hex": "01" - }, - { - "name": " 2", - "label": "2", - "hex": "02" - }, - { - "name": " 3", - "label": "3", - "hex": "03" - }, - { - "name": " 4", - "label": "4", - "hex": "04" - }, - { - "name": " 5", - "label": "5", - "hex": "05" - }, - { - "name": " 6", - "label": "6", - "hex": "06" - }, - { - "name": " 7", - "label": "7", - "hex": "07" - }, - { - "name": " 8", - "label": "8", - "hex": "08" - }, - { - "name": " 9", - "label": "9", - "hex": "09" - }, - { - "name": " 10", - "label": "10", - "hex": "0A" - }, - { - "name": " 11", - "label": "11", - "hex": "0B" - }, - { - "name": " 12", - "label": "12", - "hex": "0C" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/mariko/cpu_high_vmin.json b/Ultrahand/OC Toolkit/mariko/cpu_high_vmin.json deleted file mode 100644 index c2828a0f..00000000 --- a/Ultrahand/OC Toolkit/mariko/cpu_high_vmin.json +++ /dev/null @@ -1,147 +0,0 @@ -[ - { - "name": "710 mV", - "label": "710 mV - -140 mV", - "hex": "C602" - }, - { - "name": "715 mV", - "label": "715 mV - -135 mV", - "hex": "CB02" - }, - { - "name": "720 mV", - "label": "720 mV - -130 mV", - "hex": "D002" - }, - { - "name": "725 mV", - "label": "725 mV - -125 mV", - "hex": "D502" - }, - { - "name": "730 mV", - "label": "730 mV - -120 mV", - "hex": "DA02" - }, - { - "name": "735 mV", - "label": "735 mV - -115 mV", - "hex": "DF02" - }, - { - "name": "740 mV", - "label": "740 mV - -110 mV", - "hex": "E402" - }, - { - "name": "745 mV", - "label": "745 mV - -105 mV", - "hex": "E902" - }, - { - "name": "750 mV", - "label": "750 mV - -100 mV", - "hex": "EE02" - }, - { - "name": "755 mV", - "label": "755 mV - -95 mV", - "hex": "F302" - }, - { - "name": "760 mV", - "label": "760 mV - -90 mV", - "hex": "F802" - }, - { - "name": "765 mV", - "label": "765 mV - -85 mV", - "hex": "FD02" - }, - { - "name": "770 mV", - "label": "770 mV - -80 mV", - "hex": "0203" - }, - { - "name": "775 mV", - "label": "775 mV - -75 mV", - "hex": "0703" - }, - { - "name": "780 mV", - "label": "780 mV - -70 mV", - "hex": "0C03" - }, - { - "name": "785 mV", - "label": "785 mV - -65 mV", - "hex": "1103" - }, - { - "name": "790 mV", - "label": "790 mV - -60 mV", - "hex": "1603" - }, - { - "name": "795 mV", - "label": "795 mV - -55 mV", - "hex": "1B03" - }, - { - "name": "800 mV", - "label": "800 mV - -50 mV", - "hex": "2003" - }, - { - "name": "805 mV", - "label": "805 mV - -45 mV", - "hex": "2503" - }, - { - "name": "810 mV", - "label": "810 mV - -40 mV", - "hex": "2A03" - }, - { - "name": "815 mV", - "label": "815 mV - -35 mV", - "hex": "2F03" - }, - { - "name": "820 mV", - "label": "820 mV - -30 mV", - "hex": "3403" - }, - { - "name": "825 mV", - "label": "825 mV - -25 mV", - "hex": "3903" - }, - { - "name": "830 mV", - "label": "830 mV - -20 mV", - "hex": "3E03" - }, - { - "name": "835 mV", - "label": "835 mV - -15 mV", - "hex": "4303" - }, - { - "name": "840 mV", - "label": "840 mV - -10 mV", - "hex": "4803" - }, - { - "name": "845 mV", - "label": "845 mV - -5 mV", - "hex": "4D03" - }, - { - "name": "850 mV", - "label": "850 mV - default", - "hex": "5203" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/mariko/cpu_low_vmin.json b/Ultrahand/OC Toolkit/mariko/cpu_low_vmin.json deleted file mode 100644 index d3676cd3..00000000 --- a/Ultrahand/OC Toolkit/mariko/cpu_low_vmin.json +++ /dev/null @@ -1,107 +0,0 @@ -[ - { - "name": "550 mV", - "label": "550 mV - -70 mV", - "hex": "2602" - }, - { - "name": "555 mV", - "label": "555 mV - -65 mV", - "hex": "2B02" - }, - { - "name": "560 mV", - "label": "560 mV - -60 mV", - "hex": "3002" - }, - { - "name": "565 mV", - "label": "565 mV - -55 mV", - "hex": "3502" - }, - { - "name": "570 mV", - "label": "570 mV - -50 mV", - "hex": "3A02" - }, - { - "name": "575 mV", - "label": "575 mV - -45 mV", - "hex": "3F02" - }, - { - "name": "580 mV", - "label": "580 mV - -40 mV", - "hex": "4402" - }, - { - "name": "585 mV", - "label": "585 mV - -35 mV", - "hex": "4902" - }, - { - "name": "590 mV", - "label": "590 mV - -30 mV", - "hex": "4E02" - }, - { - "name": "595 mV", - "label": "595 mV - -25 mV", - "hex": "5302" - }, - { - "name": "600 mV", - "label": "600 mV - -20 mV", - "hex": "5802" - }, - { - "name": "605 mV", - "label": "605 mV - -15 mV", - "hex": "5D02" - }, - { - "name": "610 mV", - "label": "610 mV - -10 mV", - "hex": "6202" - }, - { - "name": "615 mV", - "label": "615 mV - -5 mV", - "hex": "6702" - }, - { - "name": "620 mV", - "label": "620 mV - default", - "hex": "6C02" - }, - { - "name": "625 mV", - "label": "625 mV - +5 mV", - "hex": "7102" - }, - { - "name": "630 mV", - "label": "630 mV - +10 mV", - "hex": "7602" - }, - { - "name": "635 mV", - "label": "635 mV - +15 mV", - "hex": "7B02" - }, - { - "name": "640 mV", - "label": "640 mV - +20 mV", - "hex": "8002" - }, - { - "name": "645 mV", - "label": "645 mV - +25 mV", - "hex": "8502" - }, - { - "name": "650 mV", - "label": "650 mV - +30 mV", - "hex": "8A02" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/mariko/cpu_max_freq.json b/Ultrahand/OC Toolkit/mariko/cpu_max_freq.json deleted file mode 100644 index 0c78c06d..00000000 --- a/Ultrahand/OC Toolkit/mariko/cpu_max_freq.json +++ /dev/null @@ -1,22 +0,0 @@ -[ - { - "name": "1963 MHz", - "label": "1963 MHz", - "hex": "02" - }, - { - "name": "2397 MHz", - "label": "2397 MHz", - "hex": "00" - }, - { - "name": "2499 MHz", - "label": "2499 MHz", - "hex": "03" - }, - { - "name": "2601 MHz", - "label": "2601 MHz", - "hex": "01" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/mariko/cpu_table.json b/Ultrahand/OC Toolkit/mariko/cpu_table.json deleted file mode 100644 index 828bb35f..00000000 --- a/Ultrahand/OC Toolkit/mariko/cpu_table.json +++ /dev/null @@ -1,27 +0,0 @@ -[ - { - "name": "Auto", - "label": "Auto - default", - "hex": "00" - }, - { - "name": "Default Table", - "label": "Default Table", - "hex": "01" - }, - { - "name": "1581 MHz Tbreak", - "label": "1581 MHz Tbreak", - "hex": "02" - }, - { - "name": "Shift Fix 1", - "label": "Shift Fix 1", - "hex": "03" - }, - { - "name": "Shift Fix 2", - "label": "Shift Fix 2", - "hex": "04" - } -] diff --git a/Ultrahand/OC Toolkit/mariko/cpu_uv.json b/Ultrahand/OC Toolkit/mariko/cpu_uv.json deleted file mode 100644 index 660f93fd..00000000 --- a/Ultrahand/OC Toolkit/mariko/cpu_uv.json +++ /dev/null @@ -1,47 +0,0 @@ -[ - { - "name": "0", - "label": " 0", - "hex": "00" - }, - { - "name": "1", - "label": " 1", - "hex": "01" - }, - { - "name": "2", - "label": " 2", - "hex": "02" - }, - { - "name": "3", - "label": " 3", - "hex": "03" - }, - { - "name": "4", - "label": " 4", - "hex": "04" - }, - { - "name": "5", - "label": " 5", - "hex": "05" - }, - { - "name": "6", - "label": " 6", - "hex": "06" - }, - { - "name": "7", - "label": " 7", - "hex": "07" - }, - { - "name": "8", - "label": " 8", - "hex": "08" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/mariko/cpu_voltages.json b/Ultrahand/OC Toolkit/mariko/cpu_voltages.json deleted file mode 100644 index ffb1f076..00000000 --- a/Ultrahand/OC Toolkit/mariko/cpu_voltages.json +++ /dev/null @@ -1,67 +0,0 @@ -[ - { - "name": "1100 mV", - "label": "1100 mV", - "hex": "4C04" - }, - { - "name": "1105 mV", - "label": "1105 mV", - "hex": "5104" - }, - { - "name": "1110 mV", - "label": "1110 mV", - "hex": "5604" - }, - { - "name": "1115 mV", - "label": "1115 mV", - "hex": "5B04" - }, - { - "name": "1120 mV", - "label": "1120 mV - default", - "hex": "6004" - }, - { - "name": "1125 mV", - "label": "1125 mV", - "hex": "6504" - }, - { - "name": "1130 mV", - "label": "1130 mV", - "hex": "6A04" - }, - { - "name": "1135 mV", - "label": "1135 mV", - "hex": "6F04" - }, - { - "name": "1140 mV", - "label": "1140 mV", - "hex": "7404" - }, - { - "name": "1145 mV", - "label": "1145 mV", - "hex": "7904" - }, - { - "name": "1150 mV", - "label": "1150 mV", - "hex": "7E04" - }, - { - "name": "1155 mV", - "label": "1155 mV", - "hex": "8304" - }, - { - "name": "1160 mV", - "label": "1160 mV", - "hex": "8804" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/mariko/gpu_speedo.json b/Ultrahand/OC Toolkit/mariko/gpu_speedo.json deleted file mode 100644 index 9ee53567..00000000 --- a/Ultrahand/OC Toolkit/mariko/gpu_speedo.json +++ /dev/null @@ -1,262 +0,0 @@ -[ - { - "name": "1480", - "hex": "C805" - }, - { - "name": "1485", - "hex": "CD05" - }, - { - "name": "1490", - "hex": "D205" - }, - { - "name": "1495", - "hex": "D705" - }, - { - "name": "1500", - "hex": "DC05" - }, - { - "name": "1505", - "hex": "E105" - }, - { - "name": "1510", - "hex": "E605" - }, - { - "name": "1515", - "hex": "EB05" - }, - { - "name": "1520", - "hex": "F005" - }, - { - "name": "1525", - "hex": "F505" - }, - { - "name": "1530", - "hex": "FA05" - }, - { - "name": "1535", - "hex": "FF05" - }, - { - "name": "1540", - "hex": "0406" - }, - { - "name": "1545", - "hex": "0906" - }, - { - "name": "1550", - "hex": "0E06" - }, - { - "name": "1555", - "hex": "1306" - }, - { - "name": "1560", - "hex": "1806" - }, - { - "name": "1565", - "hex": "1D06" - }, - { - "name": "1570", - "hex": "2206" - }, - { - "name": "1575", - "hex": "2706" - }, - { - "name": "1580", - "hex": "2C06" - }, - { - "name": "1585", - "hex": "3106" - }, - { - "name": "1590", - "hex": "3606" - }, - { - "name": "1595", - "hex": "3B06" - }, - { - "name": "1600", - "hex": "4006" - }, - { - "name": "1605", - "hex": "4506" - }, - { - "name": "1610", - "hex": "4A06" - }, - { - "name": "1615", - "hex": "4F06" - }, - { - "name": "1620", - "hex": "5406" - }, - { - "name": "1625", - "hex": "5906" - }, - { - "name": "1630", - "hex": "5E06" - }, - { - "name": "1635", - "hex": "6306" - }, - { - "name": "1640", - "hex": "6806" - }, - { - "name": "1645", - "hex": "6D06" - }, - { - "name": "1650", - "hex": "7206" - }, - { - "name": "1655", - "hex": "7706" - }, - { - "name": "1660", - "hex": "7C06" - }, - { - "name": "1665", - "hex": "8106" - }, - { - "name": "1670", - "hex": "8606" - }, - { - "name": "1675", - "hex": "8B06" - }, - { - "name": "1680", - "hex": "9006" - }, - { - "name": "1685", - "hex": "9506" - }, - { - "name": "1690", - "hex": "9A06" - }, - { - "name": "1695", - "hex": "9F06" - }, - { - "name": "1700", - "hex": "A406" - }, - { - "name": "1705", - "hex": "A906" - }, - { - "name": "1710", - "hex": "AE06" - }, - { - "name": "1715", - "hex": "B306" - }, - { - "name": "1720", - "hex": "B806" - }, - { - "name": "1725", - "hex": "BD06" - }, - { - "name": "1730", - "hex": "C206" - }, - { - "name": "1735", - "hex": "C706" - }, - { - "name": "1740", - "hex": "CC06" - }, - { - "name": "1745", - "hex": "D106" - }, - { - "name": "1750", - "hex": "D606" - }, - { - "name": "1755", - "hex": "DB06" - }, - { - "name": "1760", - "hex": "E006" - }, - { - "name": "1765", - "hex": "E506" - }, - { - "name": "1770", - "hex": "EA06" - }, - { - "name": "1775", - "hex": "EF06" - }, - { - "name": "1780", - "hex": "F406" - }, - { - "name": "1785", - "hex": "F906" - }, - { - "name": "1790", - "hex": "FE06" - }, - { - "name": "1795", - "hex": "0307" - }, - { - "name": "1800", - "hex": "0807" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/mariko/gpu_uv.json b/Ultrahand/OC Toolkit/mariko/gpu_uv.json deleted file mode 100644 index a851db8f..00000000 --- a/Ultrahand/OC Toolkit/mariko/gpu_uv.json +++ /dev/null @@ -1,17 +0,0 @@ -[ - { - "name": "0", - "label": " HiOPT 0", - "hex": "00" - }, - { - "name": "1", - "label": " HiOPT -15mV(2) 1", - "hex": "01" - }, - { - "name": "2", - "label": " high UV table 2", - "hex": "02" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/mariko/gpu_uv3.json b/Ultrahand/OC Toolkit/mariko/gpu_uv3.json deleted file mode 100644 index cf5a6569..00000000 --- a/Ultrahand/OC Toolkit/mariko/gpu_uv3.json +++ /dev/null @@ -1,387 +0,0 @@ -[ - { - "name": "Auto", - "hex": "0000", - "label": "Auto" - }, - { - "name": "disabled", - "hex": "D007", - "label": "disabled" - }, - { - "name": "480 mV", - "hex": "E001", - "label": "480 mV" - }, - { - "name": "485 mV", - "hex": "E501", - "label": "485 mV" - }, - { - "name": "490 mV", - "hex": "EA01", - "label": "490 mV" - }, - { - "name": "495 mV", - "hex": "EF01", - "label": "495 mV" - }, - { - "name": "500 mV", - "hex": "F401", - "label": "500 mV" - }, - { - "name": "505 mV", - "hex": "F901", - "label": "505 mV" - }, - { - "name": "510 mV", - "hex": "FE01", - "label": "510 mV" - }, - { - "name": "515 mV", - "hex": "0302", - "label": "515 mV" - }, - { - "name": "520 mV", - "hex": "0802", - "label": "520 mV" - }, - { - "name": "525 mV", - "hex": "0D02", - "label": "525 mV" - }, - { - "name": "530 mV", - "hex": "1202", - "label": "530 mV" - }, - { - "name": "535 mV", - "hex": "1702", - "label": "535 mV" - }, - { - "name": "540 mV", - "hex": "1C02", - "label": "540 mV" - }, - { - "name": "545 mV", - "hex": "2102", - "label": "545 mV" - }, - { - "name": "550 mV", - "hex": "2602", - "label": "550 mV" - }, - { - "name": "555 mV", - "hex": "2B02", - "label": "555 mV" - }, - { - "name": "560 mV", - "hex": "3002", - "label": "560 mV" - }, - { - "name": "565 mV", - "hex": "3502", - "label": "565 mV" - }, - { - "name": "570 mV", - "hex": "3A02", - "label": "570 mV" - }, - { - "name": "575 mV", - "hex": "3F02", - "label": "575 mV" - }, - { - "name": "580 mV", - "hex": "4402", - "label": "580 mV" - }, - { - "name": "585 mV", - "hex": "4902", - "label": "585 mV" - }, - { - "name": "590 mV", - "hex": "4E02", - "label": "590 mV" - }, - { - "name": "595 mV", - "hex": "5302", - "label": "595 mV" - }, - { - "name": "600 mV", - "hex": "5802", - "label": "600 mV" - }, - { - "name": "605 mV", - "hex": "5D02", - "label": "605 mV" - }, - { - "name": "610 mV", - "hex": "6202", - "label": "610 mV" - }, - { - "name": "615 mV", - "hex": "6702", - "label": "615 mV" - }, - { - "name": "620 mV", - "hex": "6C02", - "label": "620 mV" - }, - { - "name": "625 mV", - "hex": "7102", - "label": "625 mV" - }, - { - "name": "630 mV", - "hex": "7602", - "label": "630 mV" - }, - { - "name": "635 mV", - "hex": "7B02", - "label": "635 mV" - }, - { - "name": "640 mV", - "hex": "8002", - "label": "640 mV" - }, - { - "name": "645 mV", - "hex": "8502", - "label": "645 mV" - }, - { - "name": "650 mV", - "hex": "8A02", - "label": "650 mV" - }, - { - "name": "655 mV", - "hex": "8F02", - "label": "655 mV" - }, - { - "name": "660 mV", - "hex": "9402", - "label": "660 mV" - }, - { - "name": "665 mV", - "hex": "9902", - "label": "665 mV" - }, - { - "name": "670 mV", - "hex": "9E02", - "label": "670 mV" - }, - { - "name": "675 mV", - "hex": "A302", - "label": "675 mV" - }, - { - "name": "680 mV", - "hex": "A802", - "label": "680 mV" - }, - { - "name": "685 mV", - "hex": "AD02", - "label": "685 mV" - }, - { - "name": "690 mV", - "hex": "B202", - "label": "690 mV" - }, - { - "name": "695 mV", - "hex": "B702", - "label": "695 mV" - }, - { - "name": "700 mV", - "hex": "BC02", - "label": "700 mV" - }, - { - "name": "705 mV", - "hex": "C102", - "label": "705 mV" - }, - { - "name": "710 mV", - "hex": "C602", - "label": "710 mV" - }, - { - "name": "715 mV", - "hex": "CB02", - "label": "715 mV" - }, - { - "name": "720 mV", - "hex": "D002", - "label": "720 mV" - }, - { - "name": "725 mV", - "hex": "D502", - "label": "725 mV" - }, - { - "name": "730 mV", - "hex": "DA02", - "label": "730 mV" - }, - { - "name": "735 mV", - "hex": "DF02", - "label": "735 mV" - }, - { - "name": "740 mV", - "hex": "E402", - "label": "740 mV" - }, - { - "name": "745 mV", - "hex": "E902", - "label": "745 mV" - }, - { - "name": "750 mV", - "hex": "EE02", - "label": "750 mV" - }, - { - "name": "755 mV", - "hex": "F302", - "label": "755 mV" - }, - { - "name": "760 mV", - "hex": "F802", - "label": "760 mV" - }, - { - "name": "765 mV", - "hex": "FD02", - "label": "765 mV" - }, - { - "name": "770 mV", - "hex": "0203", - "label": "770 mV" - }, - { - "name": "775 mV", - "hex": "0703", - "label": "775 mV" - }, - { - "name": "780 mV", - "hex": "0C03", - "label": "780 mV" - }, - { - "name": "785 mV", - "hex": "1103", - "label": "785 mV" - }, - { - "name": "790 mV", - "hex": "1603", - "label": "790 mV" - }, - { - "name": "795 mV", - "hex": "1B03", - "label": "795 mV" - }, - { - "name": "800 mV", - "hex": "2003", - "label": "800 mV - unsafe" - }, - { - "name": "805 mV", - "hex": "2503", - "label": "805 mV - unsafe" - }, - { - "name": "810 mV", - "hex": "2A03", - "label": "810 mV - unsafe" - }, - { - "name": "815 mV", - "hex": "2F03", - "label": "815 mV - unsafe" - }, - { - "name": "820 mV", - "hex": "3403", - "label": "820 mV - unsafe" - }, - { - "name": "825 mV", - "hex": "3903", - "label": "825 mV - unsafe" - }, - { - "name": "830 mV", - "hex": "3E03", - "label": "830 mV - unsafe" - }, - { - "name": "835 mV", - "hex": "4303", - "label": "835 mV - unsafe" - }, - { - "name": "840 mV", - "hex": "4803", - "label": "840 mV - unsafe" - }, - { - "name": "845 mV", - "hex": "4D03", - "label": "845 mV - unsafe" - }, - { - "name": "850 mV", - "hex": "5203", - "label": "850 mV - unsafe" - } -] diff --git a/Ultrahand/OC Toolkit/mariko/gpu_uv3_e.json b/Ultrahand/OC Toolkit/mariko/gpu_uv3_e.json deleted file mode 100644 index 01254319..00000000 --- a/Ultrahand/OC Toolkit/mariko/gpu_uv3_e.json +++ /dev/null @@ -1,382 +0,0 @@ -[ - { - "name": "disabled", - "hex": "D007", - "label": "disabled" - }, - { - "name": "480 mV", - "hex": "E001", - "label": "480 mV" - }, - { - "name": "485 mV", - "hex": "E501", - "label": "485 mV" - }, - { - "name": "490 mV", - "hex": "EA01", - "label": "490 mV" - }, - { - "name": "495 mV", - "hex": "EF01", - "label": "495 mV" - }, - { - "name": "500 mV", - "hex": "F401", - "label": "500 mV" - }, - { - "name": "505 mV", - "hex": "F901", - "label": "505 mV" - }, - { - "name": "510 mV", - "hex": "FE01", - "label": "510 mV" - }, - { - "name": "515 mV", - "hex": "0302", - "label": "515 mV" - }, - { - "name": "520 mV", - "hex": "0802", - "label": "520 mV" - }, - { - "name": "525 mV", - "hex": "0D02", - "label": "525 mV" - }, - { - "name": "530 mV", - "hex": "1202", - "label": "530 mV" - }, - { - "name": "535 mV", - "hex": "1702", - "label": "535 mV" - }, - { - "name": "540 mV", - "hex": "1C02", - "label": "540 mV" - }, - { - "name": "545 mV", - "hex": "2102", - "label": "545 mV" - }, - { - "name": "550 mV", - "hex": "2602", - "label": "550 mV" - }, - { - "name": "555 mV", - "hex": "2B02", - "label": "555 mV" - }, - { - "name": "560 mV", - "hex": "3002", - "label": "560 mV" - }, - { - "name": "565 mV", - "hex": "3502", - "label": "565 mV" - }, - { - "name": "570 mV", - "hex": "3A02", - "label": "570 mV" - }, - { - "name": "575 mV", - "hex": "3F02", - "label": "575 mV" - }, - { - "name": "580 mV", - "hex": "4402", - "label": "580 mV" - }, - { - "name": "585 mV", - "hex": "4902", - "label": "585 mV" - }, - { - "name": "590 mV", - "hex": "4E02", - "label": "590 mV" - }, - { - "name": "595 mV", - "hex": "5302", - "label": "595 mV" - }, - { - "name": "600 mV", - "hex": "5802", - "label": "600 mV" - }, - { - "name": "605 mV", - "hex": "5D02", - "label": "605 mV" - }, - { - "name": "610 mV", - "hex": "6202", - "label": "610 mV" - }, - { - "name": "615 mV", - "hex": "6702", - "label": "615 mV" - }, - { - "name": "620 mV", - "hex": "6C02", - "label": "620 mV" - }, - { - "name": "625 mV", - "hex": "7102", - "label": "625 mV" - }, - { - "name": "630 mV", - "hex": "7602", - "label": "630 mV" - }, - { - "name": "635 mV", - "hex": "7B02", - "label": "635 mV" - }, - { - "name": "640 mV", - "hex": "8002", - "label": "640 mV" - }, - { - "name": "645 mV", - "hex": "8502", - "label": "645 mV" - }, - { - "name": "650 mV", - "hex": "8A02", - "label": "650 mV" - }, - { - "name": "655 mV", - "hex": "8F02", - "label": "655 mV" - }, - { - "name": "660 mV", - "hex": "9402", - "label": "660 mV" - }, - { - "name": "665 mV", - "hex": "9902", - "label": "665 mV" - }, - { - "name": "670 mV", - "hex": "9E02", - "label": "670 mV" - }, - { - "name": "675 mV", - "hex": "A302", - "label": "675 mV" - }, - { - "name": "680 mV", - "hex": "A802", - "label": "680 mV" - }, - { - "name": "685 mV", - "hex": "AD02", - "label": "685 mV" - }, - { - "name": "690 mV", - "hex": "B202", - "label": "690 mV" - }, - { - "name": "695 mV", - "hex": "B702", - "label": "695 mV" - }, - { - "name": "700 mV", - "hex": "BC02", - "label": "700 mV" - }, - { - "name": "705 mV", - "hex": "C102", - "label": "705 mV" - }, - { - "name": "710 mV", - "hex": "C602", - "label": "710 mV" - }, - { - "name": "715 mV", - "hex": "CB02", - "label": "715 mV" - }, - { - "name": "720 mV", - "hex": "D002", - "label": "720 mV" - }, - { - "name": "725 mV", - "hex": "D502", - "label": "725 mV" - }, - { - "name": "730 mV", - "hex": "DA02", - "label": "730 mV" - }, - { - "name": "735 mV", - "hex": "DF02", - "label": "735 mV" - }, - { - "name": "740 mV", - "hex": "E402", - "label": "740 mV" - }, - { - "name": "745 mV", - "hex": "E902", - "label": "745 mV" - }, - { - "name": "750 mV", - "hex": "EE02", - "label": "750 mV" - }, - { - "name": "755 mV", - "hex": "F302", - "label": "755 mV" - }, - { - "name": "760 mV", - "hex": "F802", - "label": "760 mV" - }, - { - "name": "765 mV", - "hex": "FD02", - "label": "765 mV" - }, - { - "name": "770 mV", - "hex": "0203", - "label": "770 mV" - }, - { - "name": "775 mV", - "hex": "0703", - "label": "775 mV" - }, - { - "name": "780 mV", - "hex": "0C03", - "label": "780 mV" - }, - { - "name": "785 mV", - "hex": "1103", - "label": "785 mV" - }, - { - "name": "790 mV", - "hex": "1603", - "label": "790 mV" - }, - { - "name": "795 mV", - "hex": "1B03", - "label": "795 mV" - }, - { - "name": "800 mV", - "hex": "2003", - "label": "800 mV - unsafe" - }, - { - "name": "805 mV", - "hex": "2503", - "label": "805 mV - unsafe" - }, - { - "name": "810 mV", - "hex": "2A03", - "label": "810 mV - unsafe" - }, - { - "name": "815 mV", - "hex": "2F03", - "label": "815 mV - unsafe" - }, - { - "name": "820 mV", - "hex": "3403", - "label": "820 mV - unsafe" - }, - { - "name": "825 mV", - "hex": "3903", - "label": "825 mV - unsafe" - }, - { - "name": "830 mV", - "hex": "3E03", - "label": "830 mV - unsafe" - }, - { - "name": "835 mV", - "hex": "4303", - "label": "835 mV - unsafe" - }, - { - "name": "840 mV", - "hex": "4803", - "label": "840 mV - unsafe" - }, - { - "name": "845 mV", - "hex": "4D03", - "label": "845 mV - unsafe" - }, - { - "name": "850 mV", - "hex": "5203", - "label": "850 mV - unsafe" - } -] diff --git a/Ultrahand/OC Toolkit/mariko/gpu_vmax.json b/Ultrahand/OC Toolkit/mariko/gpu_vmax.json deleted file mode 100644 index 1ec54f94..00000000 --- a/Ultrahand/OC Toolkit/mariko/gpu_vmax.json +++ /dev/null @@ -1,46 +0,0 @@ -[ - { - "name": "800 mV", - "hex": "2003" - }, - { - "name": "805 mV", - "hex": "2503" - }, - { - "name": "810 mV", - "hex": "2A03" - }, - { - "name": "815 mV", - "hex": "2F03" - }, - { - "name": "820 mV", - "hex": "3403" - }, - { - "name": "825 mV", - "hex": "3903" - }, - { - "name": "830 mV", - "hex": "3E03" - }, - { - "name": "835 mV", - "hex": "4303" - }, - { - "name": "840 mV", - "hex": "4803" - }, - { - "name": "845 mV", - "hex": "4D03" - }, - { - "name": "850 mV", - "hex": "5203" - } -] diff --git a/Ultrahand/OC Toolkit/mariko/gpu_vmin.json b/Ultrahand/OC Toolkit/mariko/gpu_vmin.json deleted file mode 100644 index 9ee1bc7d..00000000 --- a/Ultrahand/OC Toolkit/mariko/gpu_vmin.json +++ /dev/null @@ -1,302 +0,0 @@ -[ - { - "name": "480 mV", - "hex": "E001" - }, - { - "name": "485 mV", - "hex": "E501" - }, - { - "name": "490 mV", - "hex": "EA01" - }, - { - "name": "495 mV", - "hex": "EF01" - }, - { - "name": "500 mV", - "hex": "F401" - }, - { - "name": "505 mV", - "hex": "F901" - }, - { - "name": "510 mV", - "hex": "FE01" - }, - { - "name": "515 mV", - "hex": "0302" - }, - { - "name": "520 mV", - "hex": "0802" - }, - { - "name": "525 mV", - "hex": "0D02" - }, - { - "name": "530 mV", - "hex": "1202" - }, - { - "name": "535 mV", - "hex": "1702" - }, - { - "name": "540 mV", - "hex": "1C02" - }, - { - "name": "545 mV", - "hex": "2102" - }, - { - "name": "550 mV", - "hex": "2602" - }, - { - "name": "555 mV", - "hex": "2B02" - }, - { - "name": "560 mV", - "hex": "3002" - }, - { - "name": "565 mV", - "hex": "3502" - }, - { - "name": "570 mV", - "hex": "3A02" - }, - { - "name": "575 mV", - "hex": "3F02" - }, - { - "name": "580 mV", - "hex": "4402" - }, - { - "name": "585 mV", - "hex": "4902" - }, - { - "name": "590 mV", - "hex": "4E02" - }, - { - "name": "595 mV", - "hex": "5302" - }, - { - "name": "600 mV", - "hex": "5802" - }, - { - "name": "605 mV", - "hex": "5D02" - }, - { - "name": "610 mV", - "hex": "6202" - }, - { - "name": "615 mV", - "hex": "6702" - }, - { - "name": "620 mV", - "hex": "6C02" - }, - { - "name": "625 mV", - "hex": "7102" - }, - { - "name": "630 mV", - "hex": "7602" - }, - { - "name": "635 mV", - "hex": "7B02" - }, - { - "name": "640 mV", - "hex": "8002" - }, - { - "name": "645 mV", - "hex": "8502" - }, - { - "name": "650 mV", - "hex": "8A02" - }, - { - "name": "655 mV", - "hex": "8F02" - }, - { - "name": "660 mV", - "hex": "9402" - }, - { - "name": "665 mV", - "hex": "9902" - }, - { - "name": "670 mV", - "hex": "9E02" - }, - { - "name": "675 mV", - "hex": "A302" - }, - { - "name": "680 mV", - "hex": "A802" - }, - { - "name": "685 mV", - "hex": "AD02" - }, - { - "name": "690 mV", - "hex": "B202" - }, - { - "name": "695 mV", - "hex": "B702" - }, - { - "name": "700 mV", - "hex": "BC02" - }, - { - "name": "705 mV", - "hex": "C102" - }, - { - "name": "710 mV", - "hex": "C602" - }, - { - "name": "715 mV", - "hex": "CB02" - }, - { - "name": "720 mV", - "hex": "D002" - }, - { - "name": "725 mV", - "hex": "D502" - }, - { - "name": "730 mV", - "hex": "DA02" - }, - { - "name": "735 mV", - "hex": "DF02" - }, - { - "name": "740 mV", - "hex": "E402" - }, - { - "name": "745 mV", - "hex": "E902" - }, - { - "name": "750 mV", - "hex": "EE02" - }, - { - "name": "755 mV", - "hex": "F302" - }, - { - "name": "760 mV", - "hex": "F802" - }, - { - "name": "765 mV", - "hex": "FD02" - }, - { - "name": "770 mV", - "hex": "0203" - }, - { - "name": "775 mV", - "hex": "0703" - }, - { - "name": "780 mV", - "hex": "0C03" - }, - { - "name": "785 mV", - "hex": "1103" - }, - { - "name": "790 mV", - "hex": "1603" - }, - { - "name": "795 mV", - "hex": "1B03" - }, - { - "name": "800 mV", - "hex": "2003" - }, - { - "name": "805 mV", - "hex": "2503" - }, - { - "name": "810 mV", - "hex": "2A03" - }, - { - "name": "815 mV", - "hex": "2F03" - }, - { - "name": "820 mV", - "hex": "3403" - }, - { - "name": "825 mV", - "hex": "3903" - }, - { - "name": "830 mV", - "hex": "3E03" - }, - { - "name": "835 mV", - "hex": "4303" - }, - { - "name": "840 mV", - "hex": "4803" - }, - { - "name": "845 mV", - "hex": "4D03" - }, - { - "name": "850 mV", - "hex": "5203" - } -] diff --git a/Ultrahand/OC Toolkit/mariko/gpu_vmin_sys.json b/Ultrahand/OC Toolkit/mariko/gpu_vmin_sys.json deleted file mode 100644 index 9220ad90..00000000 --- a/Ultrahand/OC Toolkit/mariko/gpu_vmin_sys.json +++ /dev/null @@ -1,458 +0,0 @@ -[ - { - "name": "Auto", - "hex": "0000", - "dec": " ", - "dvfs": "2" - }, - { - "name": "480 mV", - "hex": "E001", - "dec": "480", - "dvfs": "2" - }, - { - "name": "485 mV", - "hex": "E501", - "dec": "485", - "dvfs": "2" - }, - { - "name": "490 mV", - "hex": "EA01", - "dec": "490", - "dvfs": "2" - }, - { - "name": "495 mV", - "hex": "EF01", - "dec": "495", - "dvfs": "2" - }, - { - "name": "500 mV", - "hex": "F401", - "dec": "500", - "dvfs": "2" - }, - { - "name": "505 mV", - "hex": "F901", - "dec": "505", - "dvfs": "2" - }, - { - "name": "510 mV", - "hex": "FE01", - "dec": "510", - "dvfs": "2" - }, - { - "name": "515 mV", - "hex": "0302", - "dec": "515", - "dvfs": "2" - }, - { - "name": "520 mV", - "hex": "0802", - "dec": "520", - "dvfs": "2" - }, - { - "name": "525 mV", - "hex": "0D02", - "dec": "525", - "dvfs": "2" - }, - { - "name": "530 mV", - "hex": "1202", - "dec": "530", - "dvfs": "2" - }, - { - "name": "535 mV", - "hex": "1702", - "dec": "535", - "dvfs": "2" - }, - { - "name": "540 mV", - "hex": "1C02", - "dec": "540", - "dvfs": "2" - }, - { - "name": "545 mV", - "hex": "2102", - "dec": "545", - "dvfs": "2" - }, - { - "name": "550 mV", - "hex": "2602", - "dec": "550", - "dvfs": "2" - }, - { - "name": "555 mV", - "hex": "2B02", - "dec": "555", - "dvfs": "2" - }, - { - "name": "560 mV", - "hex": "3002", - "dec": "560", - "dvfs": "2" - }, - { - "name": "565 mV", - "hex": "3502", - "dec": "565", - "dvfs": "2" - }, - { - "name": "570 mV", - "hex": "3A02", - "dec": "570", - "dvfs": "2" - }, - { - "name": "575 mV", - "hex": "3F02", - "dec": "575", - "dvfs": "2" - }, - { - "name": "580 mV", - "hex": "4402", - "dec": "580", - "dvfs": "2" - }, - { - "name": "585 mV", - "hex": "4902", - "dec": "585", - "dvfs": "2" - }, - { - "name": "590 mV", - "hex": "4E02", - "dec": "590", - "dvfs": "2" - }, - { - "name": "595 mV", - "hex": "5302", - "dec": "595", - "dvfs": "2" - }, - { - "name": "600 mV", - "hex": "5802", - "dec": "600", - "dvfs": "2" - }, - { - "name": "605 mV", - "hex": "5D02", - "dec": "605", - "dvfs": "2" - }, - { - "name": "610 mV", - "hex": "6202", - "dec": "610", - "dvfs": "2" - }, - { - "name": "615 mV", - "hex": "6702", - "dec": "615", - "dvfs": "2" - }, - { - "name": "620 mV", - "hex": "6C02", - "dec": "620", - "dvfs": "2" - }, - { - "name": "625 mV", - "hex": "7102", - "dec": "625", - "dvfs": "2" - }, - { - "name": "630 mV", - "hex": "7602", - "dec": "630", - "dvfs": "2" - }, - { - "name": "635 mV", - "hex": "7B02", - "dec": "635", - "dvfs": "2" - }, - { - "name": "640 mV", - "hex": "8002", - "dec": "640", - "dvfs": "2" - }, - { - "name": "645 mV", - "hex": "8502", - "dec": "645", - "dvfs": "2" - }, - { - "name": "650 mV", - "hex": "8A02", - "dec": "650", - "dvfs": "2" - }, - { - "name": "655 mV", - "hex": "8F02", - "dec": "655", - "dvfs": "2" - }, - { - "name": "660 mV", - "hex": "9402", - "dec": "660", - "dvfs": "2" - }, - { - "name": "665 mV", - "hex": "9902", - "dec": "665", - "dvfs": "2" - }, - { - "name": "670 mV", - "hex": "9E02", - "dec": "670", - "dvfs": "2" - }, - { - "name": "675 mV", - "hex": "A302", - "dec": "675", - "dvfs": "2" - }, - { - "name": "680 mV", - "hex": "A802", - "dec": "680", - "dvfs": "2" - }, - { - "name": "685 mV", - "hex": "AD02", - "dec": "685", - "dvfs": "2" - }, - { - "name": "690 mV", - "hex": "B202", - "dec": "690", - "dvfs": "2" - }, - { - "name": "695 mV", - "hex": "B702", - "dec": "695", - "dvfs": "2" - }, - { - "name": "700 mV", - "hex": "BC02", - "dec": "700", - "dvfs": "2" - }, - { - "name": "705 mV", - "hex": "C102", - "dec": "705", - "dvfs": "2" - }, - { - "name": "710 mV", - "hex": "C602", - "dec": "710", - "dvfs": "2" - }, - { - "name": "715 mV", - "hex": "CB02", - "dec": "715", - "dvfs": "2" - }, - { - "name": "720 mV", - "hex": "D002", - "dec": "720", - "dvfs": "2" - }, - { - "name": "725 mV", - "hex": "D502", - "dec": "725", - "dvfs": "2" - }, - { - "name": "730 mV", - "hex": "DA02", - "dec": "730", - "dvfs": "2" - }, - { - "name": "735 mV", - "hex": "DF02", - "dec": "735", - "dvfs": "2" - }, - { - "name": "740 mV", - "hex": "E402", - "dec": "740", - "dvfs": "2" - }, - { - "name": "745 mV", - "hex": "E902", - "dec": "745", - "dvfs": "2" - }, - { - "name": "750 mV", - "hex": "EE02", - "dec": "750", - "dvfs": "2" - }, - { - "name": "755 mV", - "hex": "F302", - "dec": "755", - "dvfs": "2" - }, - { - "name": "760 mV", - "hex": "F802", - "dec": "760", - "dvfs": "2" - }, - { - "name": "765 mV", - "hex": "FD02", - "dec": "765", - "dvfs": "2" - }, - { - "name": "770 mV", - "hex": "0203", - "dec": "770", - "dvfs": "2" - }, - { - "name": "775 mV", - "hex": "0703", - "dec": "775", - "dvfs": "2" - }, - { - "name": "780 mV", - "hex": "0C03", - "dec": "780", - "dvfs": "2" - }, - { - "name": "785 mV", - "hex": "1103", - "dec": "785", - "dvfs": "2" - }, - { - "name": "790 mV", - "hex": "1603", - "dec": "790", - "dvfs": "2" - }, - { - "name": "795 mV", - "hex": "1B03", - "dec": "795", - "dvfs": "2" - }, - { - "name": "800 mV", - "hex": "2003", - "dec": "800", - "dvfs": "2" - }, - { - "name": "805 mV", - "hex": "2503", - "dec": "805", - "dvfs": "2" - }, - { - "name": "810 mV", - "hex": "2A03", - "dec": "810", - "dvfs": "2" - }, - { - "name": "815 mV", - "hex": "2F03", - "dec": "815", - "dvfs": "2" - }, - { - "name": "820 mV", - "hex": "3403", - "dec": "820", - "dvfs": "2" - }, - { - "name": "825 mV", - "hex": "3903", - "dec": "825", - "dvfs": "2" - }, - { - "name": "830 mV", - "hex": "3E03", - "dec": "830", - "dvfs": "2" - }, - { - "name": "835 mV", - "hex": "4303", - "dec": "835", - "dvfs": "2" - }, - { - "name": "840 mV", - "hex": "4803", - "dec": "840", - "dvfs": "2" - }, - { - "name": "845 mV", - "hex": "4D03", - "dec": "845", - "dvfs": "2" - }, - { - "name": "850 mV", - "hex": "5203", - "dec": "850", - "dvfs": "2" - } -] diff --git a/Ultrahand/OC Toolkit/mariko/gpu_volt_offset.json b/Ultrahand/OC Toolkit/mariko/gpu_volt_offset.json deleted file mode 100644 index 93d3ee23..00000000 --- a/Ultrahand/OC Toolkit/mariko/gpu_volt_offset.json +++ /dev/null @@ -1,46 +0,0 @@ -[ - { - "name": " 0 mV", - "hex": "00" - }, - { - "name": " -5 mV", - "hex": "05" - }, - { - "name": " -10 mV", - "hex": "0A" - }, - { - "name": " -15 mV", - "hex": "0F" - }, - { - "name": " -20 mV", - "hex": "14" - }, - { - "name": " -25 mV", - "hex": "19" - }, - { - "name": " -30 mV", - "hex": "1E" - }, - { - "name": " -35 mV", - "hex": "23" - }, - { - "name": " -40 mV", - "hex": "28" - }, - { - "name": " -45 mV", - "hex": "2D" - }, - { - "name": " -50 mV", - "hex": "32" - } -] diff --git a/Ultrahand/OC Toolkit/mariko/ram_dram_timing.json b/Ultrahand/OC Toolkit/mariko/ram_dram_timing.json deleted file mode 100644 index f86d755d..00000000 --- a/Ultrahand/OC Toolkit/mariko/ram_dram_timing.json +++ /dev/null @@ -1,11 +0,0 @@ -[ - { - "name": "AUTO_ADJ", - "hex": "00" - }, - { - "name": "AUTO_ADJ_HP", - "hex": "01" - } -] - diff --git a/Ultrahand/OC Toolkit/mariko/ram_dvb_table.json b/Ultrahand/OC Toolkit/mariko/ram_dvb_table.json deleted file mode 100644 index be8844c7..00000000 --- a/Ultrahand/OC Toolkit/mariko/ram_dvb_table.json +++ /dev/null @@ -1,42 +0,0 @@ -[ - { - "name": "-2", - "label": " -2", - "hex": "FEFFFFFF" - }, - { - "name": "-1", - "label": " -1", - "hex": "FFFFFFFF" - }, - { - "name": "0", - "label": " 0", - "hex": "00000000" - }, - { - "name": "1", - "label": " 1", - "hex": "01000000" - }, - { - "name": "2", - "label": " 2", - "hex": "02000000" - }, - { - "name": "3", - "label": " 3", - "hex": "03000000" - }, - { - "name": "4", - "label": " 4", - "hex": "04000000" - }, - { - "name": "5", - "label": " 5", - "hex": "05000000" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/mariko/ram_freqs.json b/Ultrahand/OC Toolkit/mariko/ram_freqs.json deleted file mode 100644 index 40fe991a..00000000 --- a/Ultrahand/OC Toolkit/mariko/ram_freqs.json +++ /dev/null @@ -1,247 +0,0 @@ -[ - { - "name": "1600 MHz", - "label": "1600 MHz", - "hex": "006A18" - }, - { - "name": "1633 MHz", - "label": "1633 MHz", - "hex": "E8EA18" - }, - { - "name": "1666 MHz", - "label": "1666 MHz", - "hex": "D06B19" - }, - { - "name": "1700 MHz", - "label": "1700 MHz", - "hex": "A0F019" - }, - { - "name": "1733 MHz", - "label": "1733 MHz", - "hex": "88711A" - }, - { - "name": "1766 MHz", - "label": "1766 MHz", - "hex": "70F21A" - }, - { - "name": "1800 MHz", - "label": "1800 MHz", - "hex": "40771B" - }, - { - "name": "1833 MHz", - "label": "1833 MHz", - "hex": "28F81B" - }, - { - "name": "1866 MHz", - "label": "1866 MHz", - "hex": "10791C" - }, - { - "name": "1900 MHz", - "label": "1900 MHz", - "hex": "E0FD1C" - }, - { - "name": "1933 MHz", - "label": "1933 MHz", - "hex": "C87E1D" - }, - { - "name": "1966 MHz", - "label": "1966 MHz", - "hex": "B0FF1D" - }, - { - "name": "2000 MHz", - "label": "2000 MHz", - "hex": "80841E" - }, - { - "name": "2033 MHz", - "label": "2033 MHz", - "hex": "68051F" - }, - { - "name": "2066 MHz", - "label": "2066 MHz", - "hex": "50861F" - }, - { - "name": "2100 MHz", - "label": "2100 MHz", - "hex": "200B20" - }, - { - "name": "2133 MHz", - "label": "2133 MHz", - "hex": "088C20" - }, - { - "name": "2166 MHz", - "label": "2166 MHz", - "hex": "F00C21" - }, - { - "name": "2200 MHz", - "label": "2200 MHz", - "hex": "C09121" - }, - { - "name": "2233 MHz", - "label": "2233 MHz", - "hex": "A81222" - }, - { - "name": "2266 MHz", - "label": "2266 MHz", - "hex": "909322" - }, - { - "name": "2300 MHz", - "label": "2300 MHz", - "hex": "601823" - }, - { - "name": "2333 MHz", - "label": "2333 MHz", - "hex": "489923" - }, - { - "name": "2366 MHz", - "label": "2366 MHz", - "hex": "301A24" - }, - { - "name": "2400 MHz", - "label": "2400 MHz", - "hex": "009F24" - }, - { - "name": "2433 MHz", - "label": "2433 MHz", - "hex": "E81F25" - }, - { - "name": "2466 MHz", - "label": "2466 MHz", - "hex": "D0A025" - }, - { - "name": "2500 MHz", - "label": "2500 MHz", - "hex": "A02526" - }, - { - "name": "2533 MHz", - "label": "2533 MHz", - "hex": "88A626" - }, - { - "name": "2566 MHz", - "label": "2566 MHz", - "hex": "702727" - }, - { - "name": "2600 MHz", - "label": "2600 MHz", - "hex": "40AC27" - }, - { - "name": "2633 MHz", - "label": "2633 MHz", - "hex": "282D28" - }, - { - "name": "2666 MHz", - "label": "2666 MHz", - "hex": "10AE28" - }, - { - "name": "2700 MHz", - "label": "2700 MHz", - "hex": "E03229" - }, - { - "name": "2733 MHz", - "label": "2733 MHz", - "hex": "C8B329" - }, - { - "name": "2766 MHz", - "label": "2766 MHz", - "hex": "B0342A" - }, - { - "name": "2800 MHz", - "label": "2800 MHz", - "hex": "80B92A" - }, - { - "name": "2833 MHz", - "label": "2833 MHz", - "hex": "683A2B" - }, - { - "name": "2866 MHz", - "label": "2866 MHz", - "hex": "50BB2B" - }, - { - "name": "2900 MHz", - "label": "2900 MHz", - "hex": "20402C" - }, - { - "name": "2933 MHz", - "label": "2933 MHz", - "hex": "08C12C" - }, - { - "name": "2966 MHz", - "label": "2966 MHz", - "hex": "F0412D" - }, - { - "name": "3000 MHz", - "label": "3000 MHz", - "hex": "C0C62D" - }, - { - "name": "3033 MHz", - "label": "3033 MHz", - "hex": "A8472E" - }, - { - "name": "3066 MHz", - "label": "3066 MHz", - "hex": "90C82E" - }, - { - "name": "3100 MHz", - "label": "3100 MHz", - "hex": "604D2F" - }, - { - "name": "3133 MHz", - "label": "3133 MHz", - "hex": "48CE2F" - }, - { - "name": "3166 MHz", - "label": "3166 MHz", - "hex": "304F30" - }, - { - "name": "3200 MHz", - "label": "3200 MHz", - "hex": "00D430" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/mariko/ram_tras.json b/Ultrahand/OC Toolkit/mariko/ram_tras.json deleted file mode 100644 index 5483b327..00000000 --- a/Ultrahand/OC Toolkit/mariko/ram_tras.json +++ /dev/null @@ -1,52 +0,0 @@ -[ - { - "name": "42", - "label": "(42) 0", - "hex": "00" - }, - { - "name": "36", - "label": "(36) 1", - "hex": "01" - }, - { - "name": "34", - "label": "(34) 2", - "hex": "02" - }, - { - "name": "32", - "label": "(32) 3", - "hex": "03" - }, - { - "name": "30", - "label": "(30) 4", - "hex": "04" - }, - { - "name": "28", - "label": "(28) 5", - "hex": "05" - }, - { - "name": "26", - "label": "(26) 6", - "hex": "06" - }, - { - "name": "24", - "label": "(24) 7", - "hex": "07" - }, - { - "name": "22", - "label": "(22) 8", - "hex": "08" - }, - { - "name": "20", - "label": "(20) 9", - "hex": "09" - } -] diff --git a/Ultrahand/OC Toolkit/mariko/ram_trcd.json b/Ultrahand/OC Toolkit/mariko/ram_trcd.json deleted file mode 100644 index 99c70eea..00000000 --- a/Ultrahand/OC Toolkit/mariko/ram_trcd.json +++ /dev/null @@ -1,42 +0,0 @@ -[ - { - "name": "18 - (0)", - "label": "(18) 0", - "hex": "00" - }, - { - "name": "17 - (1)", - "label": "(17) 1", - "hex": "01" - }, - { - "name": "16 - (2)", - "label": "(16) 2", - "hex": "02" - }, - { - "name": "15 - (3)", - "label": "(15) 3", - "hex": "03" - }, - { - "name": "14 - (4)", - "label": "(14) 4", - "hex": "04" - }, - { - "name": "13 - (5)", - "label": "(13) 5", - "hex": "05" - }, - { - "name": "12 - (6)", - "label": "(12) 6", - "hex": "06" - }, - { - "name": "11 - (7)", - "label": "(11) 7", - "hex": "07" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/mariko/ram_trefi.json b/Ultrahand/OC Toolkit/mariko/ram_trefi.json deleted file mode 100644 index 6fe0db3a..00000000 --- a/Ultrahand/OC Toolkit/mariko/ram_trefi.json +++ /dev/null @@ -1,37 +0,0 @@ -[ - { - "name": "(1x REFI) 0", - "label": "0", - "hex": "00" - }, - { - "name": "(1.5x REFI) 1", - "label": "1", - "hex": "01" - }, - { - "name": "(2x REFI) 2", - "label": "2", - "hex": "02" - }, - { - "name": "(3x REFI) 3", - "label": "3", - "hex": "03" - }, - { - "name": "(4x REFI) 4", - "label": "4", - "hex": "04" - }, - { - "name": "(6x REFI) 5", - "label": "5", - "hex": "05" - }, - { - "name": "(MAX REFI) 6", - "label": "6", - "hex": "06" - } -] diff --git a/Ultrahand/OC Toolkit/mariko/ram_trfc.json b/Ultrahand/OC Toolkit/mariko/ram_trfc.json deleted file mode 100644 index 89e38809..00000000 --- a/Ultrahand/OC Toolkit/mariko/ram_trfc.json +++ /dev/null @@ -1,47 +0,0 @@ -[ - { - "name": "(140) 0", - "label": "0", - "hex": "00" - }, - { - "name": "(120) 1", - "label": "1", - "hex": "01" - }, - { - "name": "(100) 2", - "label": "2", - "hex": "02" - }, - { - "name": "(90) 3", - "label": "3", - "hex": "03" - }, - { - "name": "(80) 4", - "label": "4", - "hex": "04" - }, - { - "name": "(70) 5", - "label": "5", - "hex": "05" - }, - { - "name": "(60) 6", - "label": "6", - "hex": "06" - }, - { - "name": "(50) 7", - "label": "7", - "hex": "07" - }, - { - "name": "(40) 8", - "label": "8", - "hex": "08" - } -] diff --git a/Ultrahand/OC Toolkit/mariko/ram_trp.json b/Ultrahand/OC Toolkit/mariko/ram_trp.json deleted file mode 100644 index 3d10118f..00000000 --- a/Ultrahand/OC Toolkit/mariko/ram_trp.json +++ /dev/null @@ -1,42 +0,0 @@ -[ - { - "name": "18 - (0)", - "label": " (18) 0", - "hex": "00" - }, - { - "name": "17 - (1)", - "label": " (17) 1", - "hex": "01" - }, - { - "name": "16 - (2)", - "label": " (16) 2", - "hex": "02" - }, - { - "name": "15 - (3)", - "label": " (15) 3", - "hex": "03" - }, - { - "name": "14 - (4)", - "label": " (14) 4", - "hex": "04" - }, - { - "name": "13 - (5)", - "label": " (13) 5", - "hex": "05" - }, - { - "name": "12 - (6)", - "label": " (12) 6", - "hex": "06" - }, - { - "name": "11 - (7)", - "label": " (11) 7", - "hex": "07" - } -] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/mariko/ram_trrd.json b/Ultrahand/OC Toolkit/mariko/ram_trrd.json deleted file mode 100644 index eb7bec96..00000000 --- a/Ultrahand/OC Toolkit/mariko/ram_trrd.json +++ /dev/null @@ -1,42 +0,0 @@ -[ - { - "name": "(10) 0", - "label": "0", - "hex": "00" - }, - { - "name": "(7.5) 1", - "label": "1", - "hex": "01" - }, - { - "name": "(6) 2", - "label": "2", - "hex": "02" - }, - { - "name": "(5) 3", - "label": "3", - "hex": "03" - }, - { - "name": "(4) 4", - "label": "4", - "hex": "04" - }, - { - "name": "(3) 5", - "label": "5", - "hex": "05" - }, - { - "name": "(2) 6", - "label": "6", - "hex": "06" - }, - { - "name": "(1) 7", - "label": "7", - "hex": "07" - } -] diff --git a/Ultrahand/OC Toolkit/mariko/ram_trtw.json b/Ultrahand/OC Toolkit/mariko/ram_trtw.json deleted file mode 100644 index dee58df3..00000000 --- a/Ultrahand/OC Toolkit/mariko/ram_trtw.json +++ /dev/null @@ -1,52 +0,0 @@ -[ - { - "name": " 0", - "label": "0", - "hex": "00" - }, - { - "name": " 1", - "label": "1", - "hex": "01" - }, - { - "name": " 2", - "label": "2", - "hex": "02" - }, - { - "name": " 3", - "label": "3", - "hex": "03" - }, - { - "name": " 4", - "label": "4", - "hex": "04" - }, - { - "name": " 5", - "label": "5", - "hex": "05" - }, - { - "name": " 6", - "label": "6", - "hex": "06" - }, - { - "name": " 7", - "label": "7", - "hex": "07" - }, - { - "name": " 8", - "label": "8", - "hex": "08" - }, - { - "name": " 9", - "label": "9", - "hex": "09" - } -] diff --git a/Ultrahand/OC Toolkit/mariko/ram_twtr.json b/Ultrahand/OC Toolkit/mariko/ram_twtr.json deleted file mode 100644 index c55a47bf..00000000 --- a/Ultrahand/OC Toolkit/mariko/ram_twtr.json +++ /dev/null @@ -1,52 +0,0 @@ -[ - { - "name": "(10) 0", - "label": "0", - "hex": "00" - }, - { - "name": "(9) 1", - "label": "1", - "hex": "01" - }, - { - "name": "(8) 2", - "label": "2", - "hex": "02" - }, - { - "name": "(7) 3", - "label": "3", - "hex": "03" - }, - { - "name": "(6) 4", - "label": "4", - "hex": "04" - }, - { - "name": "(5) 5", - "label": "5", - "hex": "05" - }, - { - "name": "(4) 6", - "label": "6", - "hex": "06" - }, - { - "name": "(3) 7", - "label": "7", - "hex": "07" - }, - { - "name": "(2) 8", - "label": "8", - "hex": "08" - }, - { - "name": "(1) 9", - "label": "9", - "hex": "09" - } -] diff --git a/Ultrahand/OC Toolkit/mariko/ram_vdd2.json b/Ultrahand/OC Toolkit/mariko/ram_vdd2.json deleted file mode 100644 index 1f12cc94..00000000 --- a/Ultrahand/OC Toolkit/mariko/ram_vdd2.json +++ /dev/null @@ -1,77 +0,0 @@ -[ - { - "name": "Do not override", - "label": "Do not override", - "hex": "000000" - }, - { - "name": "1050 mV", - "label": "1050 mV", - "hex": "900510" - }, - { - "name": "1062.5 mV", - "label": "1062.5 mV", - "hex": "643610" - }, - { - "name": "1075 mV", - "label": "1075 mV", - "hex": "386710" - }, - { - "name": "1087.5 mV", - "label": "1087.5 mV", - "hex": "0C9810" - }, - { - "name": "1100 mV", - "label": "1100 mV - default", - "hex": "E0C810" - }, - { - "name": "1112.5 mV", - "label": "1112.5 mV", - "hex": "B4F910" - }, - { - "name": "1125 mV", - "label": "1125 mV", - "hex": "882A11" - }, - { - "name": "1137.5 mV", - "label": "1137.5 mV", - "hex": "5C5B11" - }, - { - "name": "1150 mV", - "label": "1150 mV", - "hex": "308C11" - }, - { - "name": "1162.5 mV", - "label": "1162.5 mV", - "hex": "04BD11" - }, - { - "name": "1175 mV", - "label": "1175 mV", - "hex": "D8ED11" - }, - { - "name": "1187.5 mV", - "label": "1187.5 mV", - "hex": "AC1E12" - }, - { - "name": "1200 mV", - "label": "1200 mV", - "hex": "804F12" - }, - { - "name": "1212.5 mV", - "label": "1212.5 mV", - "hex": "548012" - } -] diff --git a/Ultrahand/OC Toolkit/mariko/ram_vddq.json b/Ultrahand/OC Toolkit/mariko/ram_vddq.json deleted file mode 100644 index 896f6975..00000000 --- a/Ultrahand/OC Toolkit/mariko/ram_vddq.json +++ /dev/null @@ -1,112 +0,0 @@ -[ - { - "name": "Do not override", - "label": "Do not override", - "hex": "000000" - }, - { - "name": "550 mV", - "label": "550 mV", - "hex": "706408" - }, - { - "name": "555 mV", - "label": "555 mV", - "hex": "F87708" - }, - { - "name": "560 mV", - "label": "560 mV", - "hex": "808B08" - }, - { - "name": "565 mV", - "label": "565 mV", - "hex": "089F08" - }, - { - "name": "570 mV", - "label": "570 mV", - "hex": "90B208" - }, - { - "name": "575 mV", - "label": "575 mV", - "hex": "18C608" - }, - { - "name": "580 mV", - "label": "580 mV", - "hex": "A0D908" - }, - { - "name": "585 mV", - "label": "585 mV", - "hex": "28ED08" - }, - { - "name": "590 mV", - "label": "590 mV", - "hex": "B00009" - }, - { - "name": "595 mV", - "label": "595 mV", - "hex": "381409" - }, - { - "name": "600 mV", - "label": "600 mV - default", - "hex": "C02709" - }, - { - "name": "605 mV", - "label": "605 mV", - "hex": "483B09" - }, - { - "name": "610 mV", - "label": "610 mV", - "hex": "D04E09" - }, - { - "name": "615 mV", - "label": "615 mV", - "hex": "586209" - }, - { - "name": "620 mV", - "label": "620 mV", - "hex": "E07509" - }, - { - "name": "625 mV", - "label": "625 mV", - "hex": "688909" - }, - { - "name": "630 mV", - "label": "630 mV", - "hex": "F09C09" - }, - { - "name": "635 mV", - "label": "635 mV", - "hex": "78B009" - }, - { - "name": "640 mV", - "label": "640 mV", - "hex": "00C409" - }, - { - "name": "645 mV", - "label": "645 mV", - "hex": "88D709" - }, - { - "name": "650 mV", - "label": "650 mV", - "hex": "10EB09" - } -] diff --git a/Ultrahand/OC Toolkit/package.ini b/Ultrahand/OC Toolkit/package.ini deleted file mode 100644 index fe710665..00000000 --- a/Ultrahand/OC Toolkit/package.ini +++ /dev/null @@ -1,301 +0,0 @@ -;title='Switch OCS2' -;creator='ppkantorski, Souldbminer, B3711' -;color=blue - -[@Settings] - - - - -[RAM Table package] -;version=1.6.7 -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -json_file './json/ram_model.json' -'RAM' = '{ram_vendor} {json_file(0,{ram_model})}' - - -[*Timings] -;mode=forwarder -exec cTimings -package_source './timings.ini' - - -[*DRAM] -;mode=option -json_file_source './mariko/ram_dram_timing.json' name -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 64 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*Max Clock?RAMmariko] -;system=mariko -;mode=option -;selection_mini=true -json_file_source './mariko/ram_freqs.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 80 {json_file_source(*,hex)} -hex-by-custom-rdecimal-offset /atmosphere/kips/loader.kip CUST 52 {gpu_speedo} -set-footer '{json_file_source(*,label)}' -back - - -[*Max Clock?RAMerista] -;system=erista -;mode=option -;selection_mini=true -json_file_source './erista/ram_freqs.json' label -hex-by-custom-rdecimal-offset /atmosphere/kips/loader.kip CUST 76 {json_file_source(*,dec)} -set-footer '{json_file_source(*,label)}' -back - -[*Vddq] -;system=mariko -;mode=option -;selection_mini=true -json_file_source './mariko/ram_vddq.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 72 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*Vdd2] -;mode=option -;selection_mini=true -mariko: -json_file_source './mariko/ram_vdd2.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 68 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/ram_vdd2.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 68 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[EMC DVB Table?mariko] -;system=mariko -;mode=named_step_trackbar -;unlocked=true -json_file_source './mariko/ram_dvb_table.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 84 {json_file_source(*,hex)} - - -[EMC DVB Table?erista] -;system=erista -;mode=named_step_trackbar -;unlocked=true -json_file_source './erista/ram_dvb_table.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 84 {json_file_source(*,hex)} - - - -[CPU] -[Undervolt Mode?CPU] -;mode=named_step_trackbar -;unlocked=true -mariko: -json_file_source './mariko/cpu_uv.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 12 {json_file_source(*,hex)} -erista: -json_file_source './erista/cpu_uv.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 12 {json_file_source(*,hex)} - - -[High Freq UV?CPU] -;system=mariko -;mode=named_step_trackbar -;unlocked=true -json_file_source './mariko/cpu_high_uv.json' name -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 252 {json_file_source(*,hex)} - -[*Table Config?CPUmariko] -;system=mariko -;mode=option -json_file_source './mariko/cpu_table.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 272 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*Low Freq Vmin?CPUmariko] -;system=mariko -;mode=option -;selection_mini=true -json_file_source './mariko/cpu_low_vmin.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 24 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*Vmin?CPUerista] -;system=erista -;mode=option -json_file_source './erista/cpu_low_vmin.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 16 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*High Freq Vmin?CPUmariko] -;system=mariko -;mode=option -;selection_mini=true -json_file_source './mariko/cpu_high_vmin.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 28 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*Voltage Limit?CPUmariko] -;system=mariko -;mode=option -;selection_mini=true -json_file_source './mariko/cpu_voltages.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 32 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - -[*Voltage Limit?CPUerista] -;system=erista -;mode=option -;selection_mini=true -json_file_source './erista/cpu_voltages.json' label -hex-by-custom-rdecimal-offset /atmosphere/kips/loader.kip CUST 20 {json_file_source(*,dec)} -set-footer '{json_file_source(*,name)}' -back - - - -[*Boost Clock?CPU] -;mode=option -mariko: -;selection_mini=true -json_file_source './mariko/cpu_boost_clock.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 8 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back -erista: -json_file_source './erista/cpu_boost_clock.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 8 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - - - -[GPU] -[Undervolt Mode?GPUmariko] -;system=mariko -;mode=named_step_trackbar -;unlocked=true -json_file_source './mariko/gpu_uv.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 40 {json_file_source(*,hex)} - - -[Undervolt Mode?GPUerista] -;system=erista -;mode=named_step_trackbar -;unlocked=true -json_file_source './erista/gpu_uv.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 36 {json_file_source(*,hex)} - -[*DVFS] -;system=mariko -;mode=named_step_trackbar -;unlocked=true -json_file_source './json/gpu_dvfs.json' name -set-ini-val /config/sys-clk/config.ini values gpu_dvfs {json_file_source(*,dvfs)} - - -[*DVFS Offset?GPUmariko] -;system=mariko -;mode=named_step_trackbar -;unlocked=true -json_file_source './json/gpu_dvfs_offset.json' name -set-ini-val /config/sys-clk/config.ini values gpu_dvfs_offset {json_file_source(*,dvfs)} - - -[*Vmin?GPUmariko] -;system=mariko -;mode=option -;selection_mini=true -json_file_source './mariko/gpu_vmin.json' name -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 56 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[*Vmin?GPUerista] -;system=erista -;mode=option -;selection_mini=true -json_file_source './erista/gpu_vmin.json' label -hex-by-custom-rdecimal-offset /atmosphere/kips/loader.kip CUST 48 {json_file_source(*,dec)} -set-footer '{json_file_source(*,name)}' -back - - -[*Vmax?GPU] -;system=mariko -;mode=option -;selection_mini=true -json_file_source './mariko/gpu_vmax.json' name -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 60 {json_file_source(*,hex)} -set-footer '{json_file_source(*,name)}' -back - - -[Voltage Offset] -;mode=named_step_trackbar -;unlocked=true -json_file_source './mariko/gpu_volt_offset.json' name -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 44 {json_file_source(*,hex)} -set-ini-val /config/sys-clk/config.ini values gpu_dvfs 2 - -[*Custom Table] -;mini=true -;mode=forwarder -exec cCutomTable -package_source './custom_table.ini' - - -[@Tools] - - -[Tools] -[*Info] -;mode=forwarder -package_source './info.ini' - -[Tools] -[*Backup System] -;mode=forwarder -exec cBackupSystem -package_source './backup.ini' - - -[Tools] -[*System Settings] -;mode=forwarder -exec cSystemSettings -package_source './system-settings.ini' - - - -[Tools] -[*Software Update] -;mode=forwarder -exec cUpdate -package_source './update.ini' - - - -[Reboot & Apply] -[*Reboot To] -ini_file_source /bootloader/hekate_ipl.ini -filter config -reboot boot {ini_file_source(*)} \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/preset_default.ini b/Ultrahand/OC Toolkit/preset_default.ini deleted file mode 100644 index 81694c6c..00000000 --- a/Ultrahand/OC Toolkit/preset_default.ini +++ /dev/null @@ -1,56 +0,0 @@ -;creator='ppkantorski, B3711' - - -[@Default] -[Default] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -json_file './json/ram_model.json' -'Default' = '{ram_vendor} {json_file(0,{ram_model})}' - -[D00] -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = '' -[00 - (0-0-0) 0-0-0-0-0] -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 00 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 00 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 00 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 00 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 00 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 00 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 00 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 00 -exec cTimings -exec boot - - -[gap] -;mode=table -;background=false -;gap=10 - -[D01] -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = '' -[01 - (3-3-2) 0-1-4-3-6] -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 03 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 03 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 02 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 00 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 01 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 03 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/preset_hynix.ini b/Ultrahand/OC Toolkit/preset_hynix.ini deleted file mode 100644 index 3396d913..00000000 --- a/Ultrahand/OC Toolkit/preset_hynix.ini +++ /dev/null @@ -1,117 +0,0 @@ -;creator='ppkantorski, B3711' - - -[@Hynix] -[Hynix] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -json_file './json/ram_model.json' -'Hynix' = '{ram_vendor} {json_file(0,{ram_model})}' - - -[NEE Common] -;system=mariko -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'Common' -[NEE - (3-3-2) 2-5-5-4-6] -;system=mariko -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 03 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 03 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 02 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 02 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot - - -[gap] -;system=mariko -;mode=table -;background=false -;gap=10 - -[NEE ST] -;system=mariko -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'ST' -[NEE - (4-4-4) 3-7-6-5-6] -;system=mariko -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 03 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 07 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 06 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot - - -[gap] -;system=mariko -;mode=table -;background=false -;gap=10 - - -[NME Common] -;system=mariko -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'Common' -[NME - (2-2-1) 0-1-4-3-6] -;system=mariko -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 02 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 02 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 01 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 00 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 01 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 03 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot - - -[gap] -;system=mariko -;mode=table -;background=false -;gap=10 - -[NME ST] -;system=mariko -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'ST' -[NME - (3-3-4) 0-1-4-4-6] -;system=mariko -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 03 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 03 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 00 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 01 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/preset_micron.ini b/Ultrahand/OC Toolkit/preset_micron.ini deleted file mode 100644 index 44e0cbf1..00000000 --- a/Ultrahand/OC Toolkit/preset_micron.ini +++ /dev/null @@ -1,176 +0,0 @@ -;creator='ppkantorski, B3711' - - -[@Micron] -[Hynix] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -json_file './json/ram_model.json' -'Micron' = '{ram_vendor} {json_file(0,{ram_model})}' - -[Micron WT:F Common] -;system=mariko -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'Common' -[WT:F - (4-4-2) 5-4-6-3-6] -;system=mariko -;mini=true -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 02 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 06 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 03 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot - - -[gap] -;system=mariko -;mode=table -;background=false -;gap=10 - -[Micron WT:F ST] -;system=mariko -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'ST' -[WT:F - (5-5-4) 5-5-6-5-6] -;system=mariko -;mini=true -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 06 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot - - -[gap] -;system=mariko -;mode=table -;background=false -;gap=10 - - -[Micron WT:E Common] -;system=mariko -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'Common' -[WT:E - (2-2-2) 2-4-4-4-6] -;system=mariko -;mini=true -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 02 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 02 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 02 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 02 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot - - -[gap] -;system=mariko -;mode=table -;background=false -;gap=10 - -[Micron WT:E ST] -;system=mariko -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'ST' -[WT:E - (3-5-3) 3-5-4-5-6] -;system=mariko -;mini=true -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 03 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 03 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 03 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot - - -[gap] -;system=mariko -;mode=table -;background=false -;gap=10 - -[Micron WT:B Common] -;system=mariko -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'Common' -[WT:B - (4-4-5) 5-2-6-5-6] -;system=mariko -;mini=true -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 02 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 06 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot - -[gap] -;system=mariko -;mode=table -;background=false -;gap=10 - - -[Micron WT:B ST] -;system=mariko -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'ST' -[WT:B - (6-6-7) 7-2-6-5-6] -;system=mariko -;mini=true -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 06 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 06 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 07 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 07 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 02 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 06 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/preset_samsung.ini b/Ultrahand/OC Toolkit/preset_samsung.ini deleted file mode 100644 index f9d4a8cd..00000000 --- a/Ultrahand/OC Toolkit/preset_samsung.ini +++ /dev/null @@ -1,227 +0,0 @@ -;creator='ppkantorski, B3711' - -[@Samsung] -[Samsung] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -json_file './json/ram_model.json' -'Samsung' = '{ram_vendor} {json_file(0,{ram_model})}' - - -[Samsung AA-MGCL Common] -;system=mariko -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'Common' -[AA-MGCL - (4-4-5) 5-5-6-7-6] -;system=mariko -;mini=true -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 06 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 07 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot - - -[gap] -;system=mariko -;mode=table -;background=false -;gap=10 - -[Samsung AA-MGCL ST] -;system=mariko -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'ST' -[AA-MGCL - (4-4-8) 6-5-7-8-6] -;system=mariko -;mini=true -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 08 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 06 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 07 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 08 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot - - -[gap] -;system=mariko -;mode=table -;background=false -;gap=10 - -[Samsung AM-MGCJ Common] -;system=mariko -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'Common' -[AM-MGCJ - (3-2-4) 2-4-4-4-6] -;system=mariko -;mini=true -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 03 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 02 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 02 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot - -[gap] -;system=mariko -;mode=table -;background=false -;gap=10 - - -[Samsung AM-MGCJ ST] -;system=mariko -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'ST' -[AM-MGCJ - (4-3-8) 2-5-4-4-6] -;system=mariko -;mini=true -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 03 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 08 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 02 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot - - - -[gap] -;system=mariko -;mode=table -;background=false -;gap=10 - -[Samsung AB-MGCL Common] -;system=mariko -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'Common' -[AB-MGCL - (4-4-4) 4-4-5-6-6] -;system=mariko -;mini=true -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 06 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot - -[gap] -;system=mariko -;mode=table -;background=false -;gap=10 - -[Samsung AB-MGCL ST] -;system=mariko -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'ST' -[AB-MGCL - (4-4-8) 5-5-6-8-6] -;system=mariko -;mini=true -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 08 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 06 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 08 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot - -[gap] -;system=mariko -;mode=table -;background=false -;gap=10 - -[Samsung HB-MGCH Common] -;system=erista -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'Common' -[HB-MGCH - (4-4-4) 0-1-5-4-6] -;system=erista -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 00 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 01 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot - -[gap] -;system=erista -;mode=table -;background=false -;gap=10 - -[Samsung HB-MGCH ST] -;system=erista -;mode=table -;background=false -;spacing=4 -;gap=15 -'' = 'ST' -[HB-MGCH - (4-5-9) 1-2-6-4-6] -;system=erista -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 05 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 09 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 01 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 02 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 06 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 04 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 06 -exec cTimings -exec boot diff --git a/Ultrahand/OC Toolkit/system-settings.ini b/Ultrahand/OC Toolkit/system-settings.ini deleted file mode 100644 index 06af7586..00000000 --- a/Ultrahand/OC Toolkit/system-settings.ini +++ /dev/null @@ -1,102 +0,0 @@ -;creator='ppkantorski, B3711' - - -[System Settings] - -[GPU Scheduling] -;mode=toggle?on -on: -set-ini-val /atmosphere/config/system_settings.ini am.gpu gpu_scheduling_enabled u8!0x1 -off: -set-ini-val /atmosphere/config/system_settings.ini am.gpu gpu_scheduling_enabled u8!0x0 - - -[1305 MHz+ GPU] -;system=mariko -;mode=toggle -on: -hex-by-custom-offset '/atmosphere/kips/loader.kip' CUST 256 00 -off: -hex-by-custom-offset '/atmosphere/kips/loader.kip' CUST 256 01 - -[1075 MHz+ GPU] -;system=erista -;mode=toggle -on: -hex-by-custom-offset '/atmosphere/kips/loader.kip' CUST 256 00 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 176 D007 -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 180 D007 -off: -hex-by-custom-offset '/atmosphere/kips/loader.kip' CUST 256 01 - - -[gap] -;mode=table -;background=false -;gap=10 - - ' -[Notice] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -'Notice' = '' - -[GPU Scheduling Notice Table2] -;mode=table -;background=true -;spacing=4 -;gap=30 -;info_text_color=warning -mariko: -'' = 'A GPU clocked at 1305 MHz or higher can ' -'' = 'lead to overheating and may exceed the ' -'' = 'board and PMIC limits. ' - -erista: -'' = 'A GPU clocked at 1075 MHz or higher can lead' -'' = 'to overheating and may exceed the board limits' - - -[*Extended Voltages & CPU] -;mode=forwarder -package_source './voltages.ini' -;mini=true - - -[*Fan Curve] -;mode=forwarder -package_source './fan_curve.ini' -;mini=true - -[Controller Sync] -;mode=toggle -on: -set-ini-val /atmosphere/config/system_settings.ini atmosphere enable_external_bluetooth_db u8!0x1 -off: -set-ini-val /atmosphere/config/system_settings.ini atmosphere enable_external_bluetooth_db u8!0x0 -;mini=true - -[Hold R for Homebrew] -;mode=toggle -on: -set-ini-val /atmosphere/config/override_config.ini hbl_config override_key R -off: -set-ini-val /atmosphere/config/override_config.ini hbl_config override_key !R -;mini=true - -[*Status Monitor] -;mode=option -json_file_source './json/keys.json' name -set-ini-val /config/status-monitor/config.ini status-monitor key_combo {json_file_source(*,value)} -set-footer '{json_file_source(*,name)}' - - - - - - diff --git a/Ultrahand/OC Toolkit/timing_presets.ini b/Ultrahand/OC Toolkit/timing_presets.ini deleted file mode 100644 index 0974030e..00000000 --- a/Ultrahand/OC Toolkit/timing_presets.ini +++ /dev/null @@ -1,42 +0,0 @@ -;creator='ppkantorski, B3711' - - -[@Primary Timings] -[RAM Table package] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -json_file './json/ram_model.json' -'Presets' = '{ram_vendor} {json_file(0,{ram_model})}' - -[*Samsung] -;mode=forwarder -package_source './preset_samsung.ini' - - -[*Micron] -;system=mariko -;mode=forwarder -package_source './preset_micron.ini' - - -[*Hynix] -;system=mariko -;mode=forwarder -package_source './preset_hynix.ini' - - -[*Default] -;mode=forwarder -package_source './preset_default.ini' - - - - - - - diff --git a/Ultrahand/OC Toolkit/timings.ini b/Ultrahand/OC Toolkit/timings.ini deleted file mode 100644 index cf376792..00000000 --- a/Ultrahand/OC Toolkit/timings.ini +++ /dev/null @@ -1,114 +0,0 @@ -;creator='ppkantorski, B3711' - -[@Primary Timings] -[Timings] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -json_file './json/ram_model.json' -'Timings' = '{ram_vendor} {json_file(0,{ram_model})}' -[*Presets] -;mini=true -;mode=forwarder -package_source './timing_presets.ini' - -[Gap] -;mode=table -;background=false -;header=false -;gap=20 - -[Primary Timings] -;mode=table -;background=false -;spacing=4 -;gap=20 -;header_indent=true -;info_text_color=header -;section_text_color=header -json_file './json/ram_model.json' -'Primary' = '' - - -[T1 tRCD] -;mode=named_step_trackbar -;unlocked=true -json_file_source './mariko/ram_trcd.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 {json_file_source(*,hex)} -exec cUpdateTimings - - -[T2 tRP] -;mode=named_step_trackbar -;unlocked=true -json_file_source './mariko/ram_trp.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 {json_file_source(*,hex)} -exec cUpdateTimings - -[T3 tRAS] -;mode=named_step_trackbar -;unlocked=true -json_file_source './mariko/ram_tras.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 {json_file_source(*,hex)} -exec cUpdateTimings - -[Gap] -;mode=table -;background=false -;header=false -;gap=10 - -[Secondary] -;mode=table -;background=false -;header_indent=true -;spacing=4 -;gap=20 -;info_text_color=#FFFFFF -;section_text_color=#FFFFFF -'Secondary' = '' - -[T4 tRRD] -;mode=named_step_trackbar -;unlocked=true -json_file_source './mariko/ram_trrd.json' name -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 {json_file_source(*,hex)} -exec cUpdateTimings - -[T5 tRFC] -;mode=named_step_trackbar -;unlocked=true -mariko: -json_file_source './mariko/ram_trfc.json' name -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 {json_file_source(*,hex)} -exec cUpdateTimings -erista: -json_file_source './erista/ram_trfc.json' name -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 {json_file_source(*,hex)} -exec cUpdateTimings - -[T6 tRTW] -;mode=named_step_trackbar -;unlocked=true -json_file_source './mariko/ram_trtw.json' name -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 {json_file_source(*,hex)} -exec cUpdateTimings - -[T7 tWTR] -;mode=named_step_trackbar -;unlocked=true -json_file_source './mariko/ram_twtr.json' name -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 {json_file_source(*,hex)} -exec cUpdateTimings - -[T8 tREFI] -;mode=named_step_trackbar -;unlocked=true -json_file_source './mariko/ram_trefi.json' name -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 {json_file_source(*,hex)} -exec cUpdateTimings - diff --git a/Ultrahand/OC Toolkit/update.ini b/Ultrahand/OC Toolkit/update.ini deleted file mode 100644 index b8badaa9..00000000 --- a/Ultrahand/OC Toolkit/update.ini +++ /dev/null @@ -1,192 +0,0 @@ -;title='OC Toolkit' -;creator='ppkantorski, B3711' -;about='This package was designed for advance overclock configurations. Use with caution and proper guidance.' - - -[@Software Update] - -[Version] -;mode=table -;background=true -;gap=20 -ini_file './config.ini' -'Latest Version' = '{ini_file(Update,online)}' - -[Update OC Toolkit] -try: -download https://github.com/ppkantorski/Ultrahand-Overlay/releases/latest/download/ovlmenu.ovl /config/ultrahand/downloads/ -move /config/ultrahand/downloads/ovlmenu.ovl /switch/.overlays/ovlmenu.ovl -download https://github.com/halop/OC_Toolkit_SC_EOS/releases/latest/download/OC.Toolkit.zip /config/ultrahand/downloads/ -unzip /config/ultrahand/downloads/OC.Toolkit.zip /config/ultrahand/downloads/OC.Toolkit/ -move './config.ini' '/config/ultrahand/downloads/OC.Toolkit/OC Toolkit/' -delete './' -move '/config/ultrahand/downloads/OC.Toolkit/OC Toolkit/' './' -delete /config/ultrahand/downloads/OC.Toolkit.zip -delete /config/ultrahand/downloads/OC.Toolkit/ - -[gap] -;mode=table -;background=false -;gap=30 - -[Update loader.kip] -try: -download https://github.com/halop/OC_Toolkit_SC_EOS/releases/latest/download/kip.zip /config/ultrahand/downloads/ -set-ini-val './config.ini' Backup Path 'upd' -clear hex_sum_cache -hex_file '/atmosphere/kips/loader.kip' -ini_file './config.ini' -mkdir /atmosphere/kips/.bakTK/ -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuBoost {hex_file(CUST,8,3)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuUVL {hex_file(CUST,12,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuUVH {hex_file(CUST,252,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuVminE {hex_file(CUST,16,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuVmaxE {hex_file(CUST,20,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuVminL {hex_file(CUST,24,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuVminH {hex_file(CUST,28,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup cpuVmaxM {hex_file(CUST,32,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuUVE {hex_file(CUST,36,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuUVM {hex_file(CUST,40,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuOFF {hex_file(CUST,44,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuVminE {hex_file(CUST,48,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuSpeedo {hex_file(CUST,52,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuVminM {hex_file(CUST,56,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup gpuVmax {hex_file(CUST,60,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup DRAM {hex_file(CUST,64,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup ramVDD2 {hex_file(CUST,68,3)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup ramVDDQ {hex_file(CUST,72,3)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup ramMHzE {hex_file(CUST,76,3)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup ramMHzM {hex_file(CUST,80,3)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup DVB {hex_file(CUST,84,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T1 {hex_file(CUST,88,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T2 {hex_file(CUST,92,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T3 {hex_file(CUST,96,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T4 {hex_file(CUST,100,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T5 {hex_file(CUST,104,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T6 {hex_file(CUST,108,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T7 {hex_file(CUST,112,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup T8 {hex_file(CUST,116,1)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 76UV3 {hex_file(CUST,124,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 153UV3 {hex_file(CUST,128,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 230UV3 {hex_file(CUST,132,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 307UV3 {hex_file(CUST,136,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 384UV3 {hex_file(CUST,140,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 460UV3 {hex_file(CUST,144,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 537UV3 {hex_file(CUST,148,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 614UV3 {hex_file(CUST,152,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 691UV3 {hex_file(CUST,156,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 768UV3 {hex_file(CUST,160,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 844UV3 {hex_file(CUST,164,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 921UV3 {hex_file(CUST,168,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 998UV3 {hex_file(CUST,172,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1075UV3 {hex_file(CUST,176,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1152UV3 {hex_file(CUST,180,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1228UV3 {hex_file(CUST,184,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1267UV3 {hex_file(CUST,188,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1305UV3 {hex_file(CUST,192,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1344UV3 {hex_file(CUST,196,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1382UV3 {hex_file(CUST,200,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1420UV3 {hex_file(CUST,204,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1459UV3 {hex_file(CUST,208,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1497UV3 {hex_file(CUST,212,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1536UV3 {hex_file(CUST,216,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup 1305GPU {hex_file(CUST,256,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup CPUUL {hex_file(CUST,264,2)} -set-ini-val '/atmosphere/kips/.bakTK/Backup {ini_file(Backup,Path)}.ini' Backup CPUTABLE {hex_file(CUST,272,2)} -remove-ini-section './config.ini' Backup - -unzip /config/ultrahand/downloads/kip.zip /config/ultrahand/downloads/kip/ -move /atmosphere/kips/loader.kip '/atmosphere/kips/.bakTK/loader.kip.backup' -move /config/ultrahand/downloads/kip/loader.kip '/atmosphere/kips/loader.kip' -delete /config/ultrahand/downloads/kip.zip -delete /config/ultrahand/downloads/kip/ -delete '/atmosphere/kips/loader.kip.backup' - - -set-ini-val './config.ini' Backup Path '/atmosphere/kips/.bakTK/Backup upd.ini' -clear hex_sum_cache -ini_file './config.ini' -ini_file '{ini_file(Backup,Path)}' - -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 8 {ini_file(Backup,cpuBoost)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 12 {ini_file(Backup,cpuUVL)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 252 {ini_file(Backup,cpuUVH)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 16 {ini_file(Backup,cpuVminE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 20 {ini_file(Backup,cpuVmaxE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 24 {ini_file(Backup,cpuVminL)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 28 {ini_file(Backup,cpuVminH)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 32 {ini_file(Backup,cpuVmaxM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 36 {ini_file(Backup,gpuUVE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 40 {ini_file(Backup,gpuUVM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 44 {ini_file(Backup,gpuOFF)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 48 {ini_file(Backup,gpuVminE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 52 {ini_file(Backup,gpuSpeedo)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 56 {ini_file(Backup,gpuVminM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 60 {ini_file(Backup,gpuVmax)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 64 {ini_file(Backup,DRAM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 68 {ini_file(Backup,ramVDD2)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 72 {ini_file(Backup,ramVDDQ)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 76 {ini_file(Backup,ramMHzE)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 80 {ini_file(Backup,ramMHzM)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 84 {ini_file(Backup,DVB)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 88 {ini_file(Backup,T1)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 92 {ini_file(Backup,T2)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 96 {ini_file(Backup,T3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 100 {ini_file(Backup,T4)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 104 {ini_file(Backup,T5)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 108 {ini_file(Backup,T6)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 112 {ini_file(Backup,T7)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 116 {ini_file(Backup,T8)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 124 {ini_file(Backup,76UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 128 {ini_file(Backup,153UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 132 {ini_file(Backup,230UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 136 {ini_file(Backup,307UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 140 {ini_file(Backup,384UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 144 {ini_file(Backup,460UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 148 {ini_file(Backup,537UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 152 {ini_file(Backup,614UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 156 {ini_file(Backup,691UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 160 {ini_file(Backup,768UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 164 {ini_file(Backup,844UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 168 {ini_file(Backup,921UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 172 {ini_file(Backup,998UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 176 {ini_file(Backup,1075UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 180 {ini_file(Backup,1152UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 184 {ini_file(Backup,1228UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 188 {ini_file(Backup,1267UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 192 {ini_file(Backup,1305UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 196 {ini_file(Backup,1344UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 200 {ini_file(Backup,1382UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 204 {ini_file(Backup,1420UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 208 {ini_file(Backup,1459UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 212 {ini_file(Backup,1497UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 216 {ini_file(Backup,1536UV3)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 256 {ini_file(Backup,1305GPU)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 264 {ini_file(Backup,CPUUL)} -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 272 {ini_file(Backup,CPUTABLE)} -delete '/atmosphere/kips/.bakTK/Backup upd.ini' -exec boot - - -[gap] -;mode=table -;background=false -;gap=30 - - -[Update sys-clk-eos] -try: -download https://github.com/halop/OC_Toolkit_SC_EOS/releases/latest/download/sys-clk.zip /config/ultrahand/downloads/ -unzip /config/ultrahand/downloads/sys-clk.zip /config/ultrahand/downloads/sys-clk/ -move '/config/ultrahand/downloads/sys-clk/' '/' -delete /config/ultrahand/downloads/sys-clk.zip -delete /config/ultrahand/downloads/sys-clk/ - - -[gap] -;mode=table -;background=false -;gap=30 - - -[Package Info] \ No newline at end of file diff --git a/Ultrahand/OC Toolkit/voltages.ini b/Ultrahand/OC Toolkit/voltages.ini deleted file mode 100644 index 27f3ce58..00000000 --- a/Ultrahand/OC Toolkit/voltages.ini +++ /dev/null @@ -1,94 +0,0 @@ -;creator='ppkantorski, B3711' -;show_version=true - -[Extended Voltages & CPU] -[Max CPU Freq?mariko] -;system=mariko -;mode=named_step_trackbar -;unlocked=true -json_file_source './mariko/cpu_max_freq.json' label -hex-by-custom-offset /atmosphere/kips/loader.kip CUST 264 {json_file_source(*,hex)} - - -[2295 MHz CPU] -;system=erista -;mode=toggle -on: -hex-by-custom-offset '/atmosphere/kips/loader.kip' CUST 264 01 -off: -hex-by-custom-offset '/atmosphere/kips/loader.kip' CUST 264 00 - -[gap] -;mode=table -;background=false -;gap=20 - - - -[2601 MHz CPU Notice Table2] -;mode=table -;spacing=4 -;gap=40 -;info_text_color=warning -mariko: -'' = '2601 MHz exceeds the PMIC limit ' -'' = 'on most switches. ' ' -erista: -'' = '2295 MHz may be unstable. ' - - - -[*Extended Voltages] -;mini=true -;mode=forwarder -package_source './extended_voltages.ini' - -[gap] -;mode=table -;background=false -;gap=5 - - -[RAMgap1] -;mode=table -;background=false -;gap=15 - -[RAM Table] -;mode=table -;spacing=4 -;gap=30 -mariko: -'Vddq'= '370 - 650 mV' -'Vdd2'= '912.5 - 1350 mV' -'MAX CPU'= '900 - 1235 mV' -'MAX GPU'= '800 - 960 mV' -erista: -'Vdd2'= '912.5 - 1350 mV' -'MAX GPU'= '700 - 950 mV' - - - -[Default Voltages] -;mini=true -copy '/switch/.packages/OC Toolkit/data/EOS/' './' -exec boot - -[RAMgap2] -;mode=table -;background=false -;gap=15 - -[RAM Table2] -;mode=table -;spacing=4 -;gap=4 -mariko: -'Vddq'= '550 - 650 mV' -'Vdd2'= '1050 - 1212.5 mV' -'MAX CPU'= '1100 - 1160 mV' -'MAX GPU'= '800 - 850 mV' -erista: -'Vdd2'= '1050 - 1237.5 mV' -'MAX GPU'= '700 - 995 mV' - diff --git a/build.sh b/build.sh index 6e12f59b..d06a4550 100644 --- a/build.sh +++ b/build.sh @@ -10,7 +10,6 @@ cp -r "$SRC"/. "$DEST"/ cd build/stratosphere/loader || exit 1 make -j"$(nproc)" hactool -t kip1 out/nintendo_nx_arm64_armv8a/release/loader.kip --uncompress=hoc.kip -rm out/nintendo_nx_arm64_armv8a/release/loader.kip cd ../../../ # exit cp build/stratosphere/loader/hoc.kip dist/atmosphere/kips/hoc.kip @@ -18,6 +17,12 @@ cd Source/sys-clk/ ./build.sh cp -r dist/ ../../ +cd ../../ + +cd Source/hoc-monitor/ +make -j"$(nproc)" +cp hoc-monitor.ovl ../../dist/switch/.overlays/hoc-monitor.ovl + # cd ../../Source/configurator # pip install -U pyinstaller diff --git a/dist/README.md b/dist/README.md index ee6238a5..116ce457 100644 --- a/dist/README.md +++ b/dist/README.md @@ -1,58 +1,113 @@ +
+logo -![alt text](assets/logo.png "logo") +--- +![License: GPL-2.0](https://img.shields.io/badge/GPL--2.0-red?style=for-the-badge) +![Nintendo Switch](https://img.shields.io/badge/Nintendo_Switch-E60012?style=for-the-badge\&logo=nintendo-switch\&logoColor=white) +[![Discord](https://img.shields.io/badge/Discord-5865F2?style=for-the-badge\&logo=discord\&logoColor=white)](https://discord.com/invite/S3eX47dHsB) +![VSCode](https://img.shields.io/badge/VSCode-0078D4?style=for-the-badge\&logo=visual%20studio%20code\&logoColor=white) +![C++](https://img.shields.io/badge/C%2B%2B-00599C?style=for-the-badge\&logo=c%2B%2B\&logoColor=white) +![Downloads](https://img.shields.io/github/downloads/souldbminersmwc/Horizon-OC/total.svg?style=for-the-badge) -![alt text](https://img.shields.io/badge/GPL--2.0-red?style=for-the-badge "logo") ![alt text](https://img.shields.io/badge/Nintendo_Switch-E60012?style=for-the-badge&logo=nintendo-switch&logoColor=white "logo") [![alt text](https://img.shields.io/badge/Discord-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.com/invite/S3eX47dHsB) ![alt text](https://img.shields.io/badge/VSCode-0078D4?style=for-the-badge&logo=visual%20studio%20code&logoColor=white) ![alt text](https://img.shields.io/badge/C%2B%2B-00599C?style=for-the-badge&logo=c%2B%2B&logoColor=white) [![Github All Releases](https://img.shields.io/github/downloads/souldbminersmwc/Horizon-OC/total.svg)]() +---
-### DISCLAIMER: THIS TOOL CAN BE DANGEROUS IF MISUSED. PROCEED WITH CAUTION -* Due to the design of Horizon OS, overclocking RAM can cause **NAND DAMAGE**. Ensure to have a NAND Backup
+## ⚠️ Disclaimer -A open source overclocking tool for Nintendo Switch consoles running Atmosphere custom firmware
+> **THIS TOOL CAN BE DANGEROUS IF MISUSED. PROCEED WITH CAUTION.** +> Due to the design of Horizon OS, **overclocking RAM can cause NAND DAMAGE.** +> Ensure you have a **full NAND backup** before proceeding. + +--- + +## 🌀 About + +**Horizon OC** is an open-source overclocking tool for Nintendo Switch consoles running **Atmosphere custom firmware**. +It enables advanced CPU, GPU, and RAM tuning with user-friendly configuration tools. + +--- + +## 🚀 Features + +* **CPU:** Up to `2397MHz` (Mariko) / `2091MHz` (Erista) +* **GPU:** Up to `1305MHz` (Mariko) / `998MHz` (Erista) +* **RAM:** Up to `3200MHz` (Mariko) / `2360MHz` (Erista) +* Over/undervolting support +* Built-in configurator +* Compatible with most homebrew + +> ⚡ *Higher (potentially dangerous) frequencies are unlockable.* +> ⚙️ *Exact maximum values vary per console.* + +--- + +## 🧩 Installation + +1. Ensure you have the latest versions of + + * [Atmosphere](https://github.com/Atmosphere-NX/Atmosphere) + * [Ultrahand Overlay](https://github.com/ppkantorski/Ultrahand-Overlay) +2. Download the latest **hoc.kip** file from the [Releases](../../releases) tab. +3. If using **Hekate**, edit `hekate_ipl.ini` to include: + + ``` + kip1=atmosphere/kips/* + ``` + + *(No changes needed if using fusee.)* +4. Download and extract the **Horizon OC sysmodule** to the root of your SD card. +5. Alternatively, use the **Configurator** and click the **Install** buttons for automatic setup. + +--- + +## ⚙️ Configuration + +1. Download the latest **Configurator** on your computer. +2. Run the executable. +3. Select your SD card or UMS drive. +4. Adjust overclocking settings as desired. +5. Click **Save** to apply your configuration. + +--- + +## 🧱 Building from Source + +1. Set up a development environment for compiling **Atmosphere**. +2. Clone Atmosphere: + + ```bash + git clone https://github.com/Atmosphere-NX/Atmosphere.git + ``` +3. Move the cloned folder into `build/`. +4. Insert your `Source/stratosphere` folder into `build/`. +5. Run: (On Windows you need to use "make -j %NUMBER_OF_PROCESSORS%") + + ```bash + ./build.sh + ``` -## Features: -CPU overclock up to 2397MHz on Mariko units, 2091MHz on Erista units
-GPU up to 1305MHz on Mariko units, 998MHz on Erista units
-RAM up to 3200MHz on Mariko units, 2360MHz on Erista units
-Over/undervolting
-Configurator
-Works with most homebrew
-*Higher (potentially dangerous) frequencies are unlockable*
-*The exact maximum overclock varies per console*
-## Installation -Ensure you have the latest version of [Atmosphere](https://github.com/Atmosphere-NX/Atmosphere) and [Ultrahand](https://github.com/ppkantorski/Ultrahand-Overlay) installed before continuing
-Grab latest hoc.kip from releases tab
-If using hekate, edit hekate_ipl.ini to include "kip1=atmosphere/kips/*". No need for editing if using fusee
-Download latest Horizon OC sysmodule from releases tab
-Extract sysmodule into root of SD card
+To build the Configurator: -Alternatively, you can download the configurator and click the two install buttons
+```bash +cd Source/Configurator +build.bat +# or +python -m PyInstaller --onefile --add-data "assets;assets" --icon=assets/icon.ico --noconsole src/main.py +``` +--- -## Configuration -Download the latest configurator on your computer
-Run the file
-Select the drive your SD card or UMS device is mounted as
-Configure the kip to your liking, and in the end, save it
+## 💎 Credits -## Building -Set up a development enviorment ready to compile Atmosphere
-Git clone Atmosphere, and move the cloned folder into build/
-Insert Source/stratosphere folder into build/
-Run build.sh +* **Lightos** & **Dominatorul** – RAM timings +* **KazushiMe** & **meha** – Switch-OC-Suite +* **sys-clk team** – sys-clk +* **b0rd2death** – Ultrahand sys-clk fork +* **Lightos** & **Sammybigio2011** – Early testing -To build the configurator, cd into Source/Configurator
-Run build.bat or run "python -m PyInstaller --onefile --add-data "assets;assets" --icon=assets/icon.ico --noconsole src/main.py"
- - -## Credits -Lightos for RAM timings
-meha for Switch-Oc-Suite
-sys-clk team for sys-clk
-b0rd2death for Ultrahand sys-clk fork
-Lightos and Sammybigio2011 for early testing
diff --git a/dist/atmosphere/contents/00FF0000636C6BFF/exefs.nsp b/dist/atmosphere/contents/00FF0000636C6BFF/exefs.nsp index d23c4656..3d82cdae 100644 Binary files a/dist/atmosphere/contents/00FF0000636C6BFF/exefs.nsp and b/dist/atmosphere/contents/00FF0000636C6BFF/exefs.nsp differ diff --git a/dist/atmosphere/kips/hoc.kip b/dist/atmosphere/kips/hoc.kip index d1e61529..068a23e9 100644 Binary files a/dist/atmosphere/kips/hoc.kip and b/dist/atmosphere/kips/hoc.kip differ diff --git a/dist/config/sys-clk/config.ini.template b/dist/config/sys-clk/config.ini.template deleted file mode 100644 index 4305c725..00000000 --- a/dist/config/sys-clk/config.ini.template +++ /dev/null @@ -1,19 +0,0 @@ -[values] -; Defines how often sys-clk log temperatures, in milliseconds (set 0 to disable) -temp_log_interval_ms=0 -; Defines how often sys-clk writes to the CSV, in milliseconds (set 0 to disable) -csv_write_interval_ms=0 - -; Example #1: BOTW -; Overclock CPU when docked -; Overclock MEM to docked clocks when handheld -;[01007EF00011E000] -;docked_cpu=1224 -;handheld_mem=1600 - -; Example #2: Picross -; Underclock to save battery -;[0100BA0003EEA000] -;handheld_cpu=816 -;handheld_gpu=153 -;handheld_mem=800 \ No newline at end of file diff --git a/dist/switch/.overlays/sys-clk-overlay.ovl b/dist/switch/.overlays/sys-clk-overlay.ovl deleted file mode 100644 index f87960d0..00000000 Binary files a/dist/switch/.overlays/sys-clk-overlay.ovl and /dev/null differ diff --git a/dist/switch/sys-clk-manager.nro b/dist/switch/sys-clk-manager.nro deleted file mode 100644 index 9a8914f6..00000000 Binary files a/dist/switch/sys-clk-manager.nro and /dev/null differ diff --git a/docs/img1.png b/docs/img1.png deleted file mode 100644 index ab70fab6..00000000 Binary files a/docs/img1.png and /dev/null differ diff --git a/docs/img2.png b/docs/img2.png deleted file mode 100644 index f12649e9..00000000 Binary files a/docs/img2.png and /dev/null differ diff --git a/docs/img3.png b/docs/img3.png deleted file mode 100644 index ddb4833d..00000000 Binary files a/docs/img3.png and /dev/null differ diff --git a/fix_head.sh b/fix_head.sh new file mode 100644 index 00000000..995ac58a --- /dev/null +++ b/fix_head.sh @@ -0,0 +1,2 @@ +rm -f .git/refs/remotes/origin/HEAD +git remote prune origin diff --git a/guide.md b/guide.md new file mode 100644 index 00000000..d28435ed --- /dev/null +++ b/guide.md @@ -0,0 +1,272 @@ +# Mariko OC Guide + +*Made with love by Dominatorul. Some parts of this guide belong to ChanseyIsTheBest and Lightos_* + +--- + +## Table of Contents +- [Safety Disclaimer](#safety-disclaimer) +- [Mariko Limits](#mariko-limits) +- [Monitoring Your Switch](#monitoring-your-switch) +- [Checking Speedo and RAM Type](#checking-speedo-and-ram-type) +- [RAM Tiers](#ram-tiers-higher-is-better) +- [OC Settings for Horizon OCE](#oc-settings-for-hoc) + - [CPU Settings](#cpu-settings) + - [GPU Settings](#gpu-settings) + - [RAM Settings](#ram-settings) +- [Clock Settings](#clock-settings) + - [Mariko Max Safe on Battery](#mariko-max-safe-on-battery-hac-001-01-heg-001) + - [Switch Lite Max Safe Clocks on Battery](#switch-lite-max-safe-clocks-on-battery-hdh-001) + - [Mariko Max Clocks Docked and Plugged](#mariko-max-clocks-docked-and-plugged-hac-001-01-heg-001) + - [Switch Lite Max Clocks Plugged](#switch-lite-max-clocks-plugged-hdh-001) +- [Troubleshooting](#troubleshooting) +- [How to test stability](https://rentry.co/howtoteststability) + +--- + +# Safety Disclaimer +!!! info ** Overclocking is inherently risky as it pushes the system beyond its original design. The risk level depends on how much you overclock and whether you stay within the limits of the chip and hardware.** + +!!! danger **Unstable RAM overclocking can cause SYSNAND/EMUNAND corruption and SD card corruption, particularly if done on SYSNAND. Test the overclock settings on EMUNAND and back it up before installing Horizon OC.** + +--- + +# Mariko Limits + +### Mariko PMIC Limits +- Mariko uses a **5A CPU / 10A GPU PMIC** for power delivery. +- Staying within these limits is essential for safe operation. + - Exceeding the **PMIC limit** slightly is possible, but not recommended and should be done with caution. + +Reducing the voltage (**undervolting, UV**) decreases power draw, current, heat and helps avoid exceeding pmic limit. + +### Charger IC Limit: +- 18W limit restricts overclocking for both Erista and Mariko units (12W on Switch Lite). This is the main limiting factor, but the PMIC current limits for CPU and GPU will be reached first. + +### GPU Scheduling + +This setting adjusts how much of your GPU can be utilized: + +- **On:** Limits GPU usage to ~96.7% +- **Off:** Limits GPU usage to ~99.7% (up to ~5% performance boost) +- **Recommended:** GPU scheduling **off**. +!!! danger ** Warning:** Disabling GPU Scheduling will slightly increase power draw. Use it with caution. + +--- + +# Monitoring Your Switch +- Use status monitor overlay to indicate if you've bypassed the charger IC limit (e.g., -1W displayed while charging). +- To get the best results, be sure your battery is 10-90% to display the real charging + +--- + +# Checking Speedo and RAM Type + +1. Boot Hekate. +2. Go to Console Info > HW & Fuses. +3. Note your DRAM ID, CPU Speedo 0, CPU Speedo 2, and SoC Speedo. + - Speedos typically range from 1450 to 1810. A higher speedo means less voltage is needed for the same clock speed. A speedo of 1650 is generally considered good. + +**Speedo Brackets** +> - Speedos are divided into **brackets**. +> - **CPU UV mode** depends on the position within your bracket, but the resulting **voltage** depends on your specific speedo. +> - It doesn’t matter how high you can set CPU UV mode — what matters is using your **maximum possible** CPU UV mode. + +--- + +# RAM Tiers (Higher is better) + +| Tier | RAM ID | +|-------------|------------------| +| GOD-tier | NEI/NEE, WT:B | +| S-tier | WT:F | +| A-tier | AA-MGCR, AA-MGCL | +| B-tier | AM-MGCJ, WT:E | +| C-tier | AB-MGCL | +| D-tier | NME | + +--- + +# OC Settings for Horizon OC + +## CPU Setting + +- **Voltage Limit:** + - **1120 mV:** Safe — recommended + - **1160 mV:** Use with caution + - **1235 mV:** Dangerous. Only use if you know what you are doing + +- **Boost Clock** + - Whatever is within **Voltage Limit**. + +- **Undervolt Mode:** 1–6 (start with 2). + - Increase gradually if stable and find your highest stable value. + - If the console fails to boot, lower the value. + +- **Vmin:** 590 mV + - In case you experience issues with low Freq UV, try raising Low Freq Vmin to 610-620mV. + - Going below 590mV is not recommended as it may mess up the cpu table. + +> **ℹ️ Note:** Exceeding the PMIC limit during **Boost Mode** is safe, as it only occurs for short bursts (typically under 30 seconds), preventing long-term hardware stress. + +## GPU Settings + +- **Undervolt Mode:** 2 + +- **Auto VMIN:** + - When RAM is overclocked, the minimum gpu voltage requirement is raised. + - Auto vmin automatically adjusts your vmin based on your ram clock. + - When using the base ram clocks (1600 MHz), **Auto VMIN** is not active + - **2 (Hijack method):** Recommended — provides the lowest value possible. + - **1 (Official service method):** Use only if you encounter issues with mode 2. + + - **Auto VMIN Offset:** Auto + +- **Vmin:** 550–620 mV + - Typically not worth adjusting, as you should always use max RAM. + +- **Vmax:** 800 mV + +- **Voltage Offset:** 0 + +## RAM Settings + +- **DRAM Timing:** + - **0 — AUTO_ADJ:** Auto-adjust MTC table with LPDDR4 3733 Mbps specs, 16Gb density. Change timing with Advanced Config (Default). + - **1 — AUTO_ADJ_HP:** Same as AUTO_ADJ, but with RAM power-down disabled. + + > **ℹ️ Tip:** AUTO_ADJ_HP improves latency, but some RAM modules may not handle it well. + > - First, find your max RAM clocks and timings with **AUTO_ADJ**. + > - Then test AUTO_ADJ_HP. If stable, use it — otherwise, stick to AUTO_ADJ. + +- **DVB Shift:** 1–5 + - Boosts SoC voltage to help stabilize RAM, especially at high frequencies (2400 MHz+). + - It's adviced to start of with a DVB shift of 4 and only lower it to 2-3 after finding your max ram speed. + - Higher DVB shift does not increase power draw, but it is going to increase heat slightly. + - Undervolting DVB is pointless. + +### RAM Configuration Based on Tier List + +| Tier | RAM ID | Ram Clock | VDD2 | VDDQ | Common Timings | Super Tight (ST) Timings | +|------|-----------------|------------|--------|-------|--------------------------|----------------------------| +| GOD | NEI/NEE/x267 | 2900-3500 | 1175 mV| 640 mV| (3-3-2) 2-5-5-4-6 | (4-4-4) 3-7-6-5-6 | +| GOD | WT:B | 2700-3200 | 1175 mV| 600 mV| (4-4-5) 5-2-6-5-6 | (6-6-7) 7-2-6-5-6 | +| S | AA-MGCL/MGCR | 2300–3100 | 1175 mV| 640 mV| (4-4-5) 5-5-6-7-6 | (4-4-8) 6-5-7-8-6 | +| S | WT:F | 2500–2800 | 1175 mV| 600 mV| (4-4-2) 5-4-6-3-6 | (5-5-4) 5-5-6-5-6 | +| A | AM-MGCJ | 2500–2866 | 1175 mV| 640 mV| (3-2-4) 2-4-4-4-6 | (4-3-8) 2-5-4-4-6 | +| A | WT:E | 2300-2800 | 1175 mV| 600 mV| (2-2-2) 2-4-4-4-6 | (3-5-3) 3-5-4-5-6 | +| B | NME | 2600-2800 | 1175 mV| 640 mV| (2-2-1) 0-1-4-3-6 | (3-3-4) 0-1-4-4-6 | +| C | AB-MGCL | 2133–2500 | 1175 mV| 640 mV| (4-4-4) 4-4-5-6-6 | (4-4-8) 5-5-6-8-6 | + + +### RAM Tuning Notes + +> **💡 Extra Headroom:** For an additional 66–100 MHz, try **1212.5 mV**. This can also help with tighter timings. +> ### ℹ️ Manufacturer’s Safe Limit +> - **1175 mV** is the absolute safe value guaranteed by the manufacturer. +> - Above this level, nothing is guaranteed—silicon quality may vary. +> - No damage from overvolting has been reported, but proceed at your own risk. +> - Undervolting RAM is pointless, at least **1175 mV** should be used. + +> **🧪 Testing Method:** + +> 1. Set **DVB = 4** using the standard preset. +> 2. Test with **ST (Super Tight)** timings. +> * If ST timings are **unstable**,try **common timings** or **relax** them gradually in the following order: +> `t5 → t4 → t7 → t6 → t3 → t2 → t1 → t8` +> * If ST timings are **stable**, **push beyond ST** for maximum performance by tightening parameters in this order: +> `t8 → t1 → t2 → t3 → t6 → t7 → t4 → t5` + +> **⚡ Performance:** ST timings provide enhanced performance over common timings. + +> **⚠️ Stability Notes:** +> - Lower **T5** or **T6** if you encounter issues. +> - RAM contributes the most to overall performance — prioritize finding your maximum frequency first. +> - Rarely, some modules may fail even with common timings. If so, lower timings until stable. + +## Fine Tuning (GPU) +This section is optional but recommended as it may lower voltages further. +- **Voltage Offset:** 5–20 + - The UV2 table by default is very tight but it is slightly loose in some cases. + - Voltage Offset can be used to tighten it further. + - Test with 5, 10, 15 or 20 when using UV2. + - Some GPUs may require **0** for stability. + - With very rare speedo bracket positions, higher UV offsets may work, test carefully. + + - **Auto VMIN Offset:** + - Auto at first, lower it as much as possible once you find your maximum ram frequency. + - Test **Auto VMIN Offset** stability at a medium frequency (``998 MHz`` for instance), otherwise the GPU voltage may dominate over the **Auto VMIN** voltage. + - This helps improving battery in handheld mode with high RAM OC. + - It's possible to add positive offset, but this shouldn't be used unless you have issues. + +# Clock Settings (Safe) + +### Mariko Max Safe on Battery [HAC-001(-01), HEG-001] +*Switch units available from August 2019 and beyond, includes OLED & requires modchip* +- **CPU:** 1963 MHz +- **GPU:** 998 MHz +- **RAM:** 2133 MHz – 2500+ MHz (use whatever is stable; 2400 MHz recommended for best battery life-to-performance ratio) + !!! warning ** Note:** Drawing over 8.6W on battery will cause battery issues. Please avoid doing that for extended periods! + +### Switch Lite Max Safe Clocks on Battery [HDH-001] +- **CPU:** 1785 MHz +- **GPU:** 921 MHz +- **RAM:** 2133 MHz – 2500+ MHz (use whatever is stable; 2400 MHz recommended for best battery life-to-performance ratio) + !!! warning ** Note:** Drawing over 6.5W on battery will cause battery issues. Please avoid doing that for extended periods! + +!!! note Switch Lite limits are lower due to the 12W board power limit, but counts as Mariko for all other purposes. + +### Mariko Max Clocks Docked and Plugged [HAC-001(-01), HEG-001] +*Switch units available from + + August 2019 and beyond, includes OLED & requires modchip* +- **CPU:** + - 2397 MHz: Safe to use. + - 2500 MHz: May exceed **PMIC limit**, use carefully. + - 2600 MHz: Exceeds pmic limit on most switches unless the voltage is kept low, around **1070 mV**. +> Determining truly safe voltages is difficult; we are only working with estimates. +> However, no damage has been reported from these recommendations. +- **GPU:** + - Sched **off**: 1228 MHz (safe with 1228 MHz voltage < 800 mV, otherwise use 1152 MHz) + - Sched **on**: 1267 MHz (safe with 1228 MHz voltage < 800 mV) + - 1228 MHz sched **off** outperforms 1267 MHz sched **on**, so it's recommended. + - **RAM:** + - 2133 MHz-3000 MHz+ (whatever is stable) + +### Switch Lite Max Clocks Plugged [HDH-001] +- **CPU:** + - 2397 MHz: Safe to use. + - 2500 MHz: May exceed **PMIC limit**, use carefully. + - 2600 MHz: Exceeds pmic limit on most switches unless the voltage is kept low, around **1070 mV**. +> Determining truly safe voltages is difficult; we are only working with estimates. +> However, no damage has been reported from these recommendations. +- **GPU:** + - Sched **off**: 1228 MHz (safe with 1228 MHz voltage < 800 mV, otherwise use 1152 MHz) + - Sched **on**: 1267 MHz (safe with 1228 MHz voltage < 800 mV) + - 1228 MHz sched **off** outperforms 1267 MHz sched **on**, so it's recommended. +- **RAM:** + - 2133 MHz-2800 MHz+ (whatever is stable) + +!!! note Switch Lite limits are lower due to the 12W board power limit, but counts as Mariko for all other purposes. + +--- + +# Troubleshooting + +**My Switch won't boot into EMUNAND after I have installed Horizon OC:** + +- Your atmosphere version is likely not up-to-date, update your atmosphere version. +- CPU UV level is too high, lower it or set it to 0. + +**My configs are not being applied:** +- Ensure you reboot your console after changing settings in Horizon OC. + +**I can't set my clocks above 1785/921/1600:** +- Your kip is not being loaded, check if it is located in `/atmosphere/kips` +- Your hekate_ipl.ini file is not set up correctly: + - Validate that your boot entry contains `kip1=atmosphere/kips/*.kip` + - It has to be below `pkg3=atmosphere/package3` (or fss0) + +# Need Help with Setup? + +###Follow this [guide](https://rentry.co/howtoget60fps) for a step-by-step setup. \ No newline at end of file