src/vendorcode/amd/agesa/f15/Proc/Mem/NB/OR/mns3or.c

   1 /* $NoKeywords:$ */
   2 /**
   3  * @file
   4  *
   5  * mns3or.c
   6  *
   7  * OR memory specific function to support S3 resume
   8  *
   9  * @xrefitem bom "File Content Label" "Release Content"
  10  * @e project: AGESA
  11  * @e sub-project: (Mem/NB/OR)
  12  * @e \$Revision: 59560 $ @e \$Date: 2011-09-26 11:43:44 -0600 (Mon, 26 Sep 2011) $
  13  *
  14  **/
  15 /*****************************************************************************
  16 *
  17 * Copyright (C) 2012 Advanced Micro Devices, Inc.
  18 * All rights reserved.
  19 *
  20 * Redistribution and use in source and binary forms, with or without
  21 * modification, are permitted provided that the following conditions are met:
  22 *     * Redistributions of source code must retain the above copyright
  23 *       notice, this list of conditions and the following disclaimer.
  24 *     * Redistributions in binary form must reproduce the above copyright
  25 *       notice, this list of conditions and the following disclaimer in the
  26 *       documentation and/or other materials provided with the distribution.
  27 *     * Neither the name of Advanced Micro Devices, Inc. nor the names of
  28 *       its contributors may be used to endorse or promote products derived
  29 *       from this software without specific prior written permission.
  30 *
  31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  32 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  33 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  34 * DISCLAIMED. IN NO EVENT SHALL ADVANCED MICRO DEVICES, INC. BE LIABLE FOR ANY
  35 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  36 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  37 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  38 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  39 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  40 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  41 *
  42 * ***************************************************************************
  43 *
  44 */
  45
  46 /*
  47  *----------------------------------------------------------------------------
  48  *                                MODULES USED
  49  *
  50  *----------------------------------------------------------------------------
  51  */
  52
  53
  54
  55 #include "AGESA.h"
  56 #include "AdvancedApi.h"
  57 #include "amdlib.h"
  58 #include "Ids.h"
  59 #include "OptionMemory.h"
  60 #include "mm.h"
  61 #include "mn.h"
  62 #include "S3.h"
  63 #include "mfs3.h"
  64 #include "mnor.h"
  65 #include "cpuRegisters.h"
  66 #include "cpuFamRegisters.h"
  67 #include "cpuFamilyTranslation.h"
  68 #include "F15PackageType.h"
  69 #include "mnS3or.h"
  70 #include "heapManager.h"
  71 #include "Filecode.h"
  72 CODE_GROUP (G3_DXE)
  73 RDATA_GROUP (G3_DXE)
  74
  75 #define FILECODE PROC_MEM_NB_OR_MNS3OR_FILECODE
  76
  77 /*----------------------------------------------------------------------------
  78  *                           TYPEDEFS AND STRUCTURES
  79  *
  80  *----------------------------------------------------------------------------
  81  */
  82
  83 /*----------------------------------------------------------------------------
  84  *                        PROTOTYPES OF LOCAL FUNCTIONS
  85  *
  86  *----------------------------------------------------------------------------
  87  */
  88 BOOLEAN
  89 MemS3ResumeConstructNBBlockOr (
  90   IN OUT   VOID *S3NBPtr,
  91   IN OUT   MEM_DATA_STRUCT *MemPtr,
  92   IN       UINT8 NodeID
  93   );
  94
  95 UINT16
  96 STATIC
  97 MemNS3GetRegLstPtrOr (
  98   IN OUT   MEM_NB_BLOCK *NBPtr,
  99   IN OUT   DESCRIPTOR_GROUP *DescriptPtr
 100   );
 101
 102 AGESA_STATUS
 103 STATIC
 104 MemNS3GetDeviceRegLstOr (
 105   IN       UINT32 RegisterLstID,
 106      OUT   VOID **RegisterHeader
 107   );
 108
 109 VOID
 110 STATIC
 111 MemNS3SetDfltPllLockTimeOr (
 112   IN       ACCESS_WIDTH AccessWidth,
 113   IN       PCI_ADDR Address,
 114   IN       VOID *Value,
 115   IN OUT   VOID *ConfigPtr
 116   );
 117
 118 VOID
 119 MemNS3SetDynModeChangeOr (
 120   IN       ACCESS_WIDTH AccessWidth,
 121   IN       PCI_ADDR Address,
 122   IN OUT   VOID *Value,
 123   IN OUT   VOID *ConfigPtr
 124   );
 125
 126 VOID
 127 MemNS3SaveMR0Or (
 128   IN       ACCESS_WIDTH AccessWidth,
 129   IN       PCI_ADDR Address,
 130   IN OUT   VOID *Value,
 131   IN OUT   VOID *ConfigPtr
 132   );
 133
 134 VOID
 135 MemNS3RestoreMR0SetPPDOr (
 136   IN       ACCESS_WIDTH AccessWidth,
 137   IN       PCI_ADDR Address,
 138   IN OUT   VOID *Value,
 139   IN OUT   VOID *ConfigPtr
 140   );
 141
 142 VOID
 143 STATIC
 144 MemNS3GetCSROr (
 145   IN       ACCESS_WIDTH AccessWidth,
 146   IN       PCI_ADDR Address,
 147   IN       VOID *Value,
 148   IN OUT   VOID *ConfigPtr
 149   );
 150
 151 VOID
 152 STATIC
 153 MemNS3SetCSROr (
 154   IN       ACCESS_WIDTH AccessWidth,
 155   IN       PCI_ADDR Address,
 156   IN OUT   VOID *Value,
 157   IN OUT   VOID *ConfigPtr
 158   );
 159 /*----------------------------------------------------------------------------
 160  *                          DEFINITIONS AND MACROS
 161  *
 162  *----------------------------------------------------------------------------
 163  */
 164 PCI_SPECIAL_CASE PciSpecialCaseFuncOr[] = {
 165   {MemNS3GetCSROr, MemNS3SetCSROr},
 166   {MemNS3GetBitFieldNb, MemNS3SetBitFieldNb},
 167   {MemNS3GetNBPStateDepRegUnb, MemNS3SetNBPStateDepRegUnb},
 168   { (VOID (*) (ACCESS_WIDTH, PCI_ADDR, VOID *, VOID *)) memDefRet, MemNS3SetDfltPllLockTimeOr},
 169   { (VOID (*) (ACCESS_WIDTH, PCI_ADDR, VOID *, VOID *)) memDefRet, MemNS3SetDisAutoCompUnb},
 170   { (VOID (*) (ACCESS_WIDTH, PCI_ADDR, VOID *, VOID *)) memDefRet, MemNS3SetDynModeChangeOr},
 171   { (VOID (*) (ACCESS_WIDTH, PCI_ADDR, VOID *, VOID *)) memDefRet, MemNS3DisableChannelNb},
 172   {MemNS3SaveNBRegiserUnb, MemNS3RestoreNBRegiserUnb},
 173   {MemNS3GetBitFieldNb, MemNS3SetPreDriverCalUnb},
 174   { (VOID (*) (ACCESS_WIDTH, PCI_ADDR, VOID *, VOID *)) memDefRet, MemNS3SetMemClkFreqValUnb},
 175   {MemNS3SaveMR0Or, MemNS3RestoreMR0SetPPDOr}
 176 };
 177
 178 PCI_REG_DESCRIPTOR ROMDATA S3PciPreSelfRefDescriptorOr[] = {
 179   {{0, 0, 0}, FUNC_2, 0x110, 0xFFFFF8E7},
 180   {{0, 0, 0}, FUNC_1, 0x40,  0xFFFF0703},
 181   {{0, 0, 0}, FUNC_1, 0x48,  0xFFFF0703},
 182   {{0, 0, 0}, FUNC_1, 0x50,  0xFFFF0703},
 183   {{0, 0, 0}, FUNC_1, 0x58,  0xFFFF0703},
 184   {{0, 0, 0}, FUNC_1, 0x60,  0xFFFF0703},
 185   {{0, 0, 0}, FUNC_1, 0x68,  0xFFFF0703},
 186   {{0, 0, 0}, FUNC_1, 0x70,  0xFFFF0703},
 187   {{0, 0, 0}, FUNC_1, 0x78,  0xFFFF0703},
 188   {{0, 1, 0}, FUNC_1, 0x140, 0x000000FF},
 189   {{0, 1, 0}, FUNC_1, 0x148, 0x000000FF},
 190   {{0, 1, 0}, FUNC_1, 0x150, 0x000000FF},
 191   {{0, 1, 0}, FUNC_1, 0x158, 0x000000FF},
 192   {{0, 1, 0}, FUNC_1, 0x160, 0x000000FF},
 193   {{0, 1, 0}, FUNC_1, 0x168, 0x000000FF},
 194   {{0, 1, 0}, FUNC_1, 0x170, 0x000000FF},
 195   {{0, 1, 0}, FUNC_1, 0x178, 0x000000FF},
 196   {{0, 0, 0}, FUNC_1, 0x44,  0xFFFF0707},
 197   {{0, 0, 0}, FUNC_1, 0x4C,  0xFFFF0707},
 198   {{0, 0, 0}, FUNC_1, 0x54,  0xFFFF0707},
 199   {{0, 0, 0}, FUNC_1, 0x5C,  0xFFFF0707},
 200   {{0, 0, 0}, FUNC_1, 0x64,  0xFFFF0707},
 201   {{0, 0, 0}, FUNC_1, 0x6C,  0xFFFF0707},
 202   {{0, 0, 0}, FUNC_1, 0x74,  0xFFFF0707},
 203   {{0, 0, 0}, FUNC_1, 0x7C,  0xFFFF0707},
 204   {{0, 1, 0}, FUNC_1, 0x144, 0x000000FF},
 205   {{0, 1, 0}, FUNC_1, 0x14C, 0x000000FF},
 206   {{0, 1, 0}, FUNC_1, 0x154, 0x000000FF},
 207   {{0, 1, 0}, FUNC_1, 0x15C, 0x000000FF},
 208   {{0, 1, 0}, FUNC_1, 0x164, 0x000000FF},
 209   {{0, 1, 0}, FUNC_1, 0x16C, 0x000000FF},
 210   {{0, 1, 0}, FUNC_1, 0x174, 0x000000FF},
 211   {{0, 1, 0}, FUNC_1, 0x17C, 0x000000FF},
 212   {{0, 0, 0}, FUNC_1, 0xF0,  0xFF00FF87},
 213   {{0, 0, 0}, FUNC_1, 0x120, 0x00FFFFFF},
 214   {{0, 0, 0}, FUNC_1, 0x124, 0x00FFFFFF},
 215   {{0, 0, 0}, FUNC_2, 0x10C, 0x07F3FBF9},
 216   {{0, 0, 0}, FUNC_2, 0x114, 0xFFFFFC00},
 217   {{0, 0, 0}, FUNC_2, 0x118, 0xF773FFFF},
 218   {{0, 0, 0}, FUNC_2, 0x11C, 0xAFFFFFFF},
 219   {{0, 0, 0}, FUNC_2, 0x1B0, 0xFFD3FF3F},
 220   {{0, 2, 0}, FUNC_2, 0x1B4, 0x000003FF}
 221 };
 222
 223 CONST PCI_REGISTER_BLOCK_HEADER ROMDATA S3PciPreSelfRefOr = {
 224   0,
 225   (sizeof (S3PciPreSelfRefDescriptorOr) / sizeof (PCI_REG_DESCRIPTOR)),
 226   S3PciPreSelfRefDescriptorOr,
 227   NULL
 228 };
 229
 230 CONDITIONAL_PCI_REG_DESCRIPTOR ROMDATA S3CPciPreSelfDescriptorOr[] = {
 231    // DCT 0
 232   {{7, 0, 1}, DCT0,   0x40,  0x7FF83FEF, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 233   {{7, 0, 1}, DCT0,   0x44,  0x7FF83FEF, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 234   {{7, 0, 1}, DCT0,   0x48,  0x7FF83FEF, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 235   {{7, 0, 1}, DCT0,   0x4C,  0x7FF83FEF, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 236   {{7, 0, 1}, DCT0,   0x50,  0x7FF83FEF, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 237   {{7, 0, 1}, DCT0,   0x54,  0x7FF83FEF, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 238   {{7, 0, 1}, DCT0,   0x58,  0x7FF83FEF, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 239   {{7, 0, 1}, DCT0,   0x5C,  0x7FF83FEF, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 240   {{7, 0, 1}, DCT0,   0x60,  0x7FF83FE3, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 241   {{7, 0, 1}, DCT0,   0x64,  0x7FF83FE3, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 242   {{7, 0, 1}, DCT0,   0x68,  0x7FF83FE3, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 243   {{7, 0, 1}, DCT0,   0x6C,  0x7FF83FE3, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 244   {{7, 0, 1}, DCT0,   0x78,  0x00020000, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 245   {{7, 2, 1}, DCT0,   0x80,  0x0000FFFF, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 246   {{7, 0, 1}, DCT0,   0x84,  0x00800003, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 247   {{7, 0, 1}, DCT0,   0x88,  0x3F000000, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 248   {{7, 0, 1}, DCT0,   0x8C,  0x00070000, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 249   {{7, 0, 1}, DCT0,   0x90,  0x0BFDF100, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 250   {{7, 0, 1}, DCT0,   0xA4,  0x00F07900, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 251   {{7, 0, 1}, DCT0,   0xA8,  0x3F60FFBC, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 252   {{7, 0, 1}, DCT0,   0x200, 0x3F1F1F1F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 253   {{7, 0, 1}, DCT0,   0x204, 0x0F3F0F3F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 254   {{7, 0, 1}, DCT0,   0x208, 0x07070707, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 255   {{7, 2, 1}, DCT0,   0x20C, 0x00000F1F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 256   {{2, 0, 1}, DCT0,   SET_S3_NB_PSTATE_OFFSET (0x210, 0), 0xFFCF000F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 257   {{2, 0, 1}, DCT0,   SET_S3_NB_PSTATE_OFFSET (0x210, 1), 0xFFCF000F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 258   {{2, 0, 1}, DCT0,   SET_S3_NB_PSTATE_OFFSET (0x210, 2), 0xFFCF000F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 259   {{2, 0, 1}, DCT0,   SET_S3_NB_PSTATE_OFFSET (0x210, 3), 0xFFCF000F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 260   {{7, 0, 1}, DCT0,   0x214, 0x000F0F0F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 261   {{7, 0, 1}, DCT0,   0x218, 0x0F0F0F0F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 262   {{7, 0, 1}, DCT0,   0x21C, 0x001F1F00, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 263   {{7, 2, 1}, DCT0,   0x220, 0x00001F0F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 264   {{7, 2, 1}, DCT0,   0x224, 0x0000070F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 265   {{7, 0, 1}, DCT0,   0x228, 0xFFFFFFFF, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 266   {{7, 1, 1}, DCT0,   0x22C, 0x0000001F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 267   {{7, 0, 1}, DCT0,   0x230, 0x0F0F0F0F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 268   {{7, 0, 1}, DCT0,   0x234, 0x0F0F0F0F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 269   {{7, 0, 1}, DCT0,   0x238, 0x0F0F0F0F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 270   {{7, 0, 1}, DCT0,   0x23C, 0x0F0F0F0F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 271   {{7, 2, 1}, DCT0,   0x240, 0x000077FF, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 272   {{7, 1, 1}, DCT0,   0x244, 0x0000000F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 273   {{7, 0, 1}, DCT0,   0x248, 0x3F3F1F0F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 274   {{7, 0, 1}, DCT0,   0x24C, 0x3F3F3F0F, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 275
 276   // DCT 1
 277   {{7, 0, 1}, DCT1,   0x40,  0x7FF83FEF, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 278   {{7, 0, 1}, DCT1,   0x44,  0x7FF83FEF, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 279   {{7, 0, 1}, DCT1,   0x48,  0x7FF83FEF, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 280   {{7, 0, 1}, DCT1,   0x4C,  0x7FF83FEF, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 281   {{7, 0, 1}, DCT1,   0x50,  0x7FF83FEF, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 282   {{7, 0, 1}, DCT1,   0x54,  0x7FF83FEF, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 283   {{7, 0, 1}, DCT1,   0x58,  0x7FF83FEF, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 284   {{7, 0, 1}, DCT1,   0x5C,  0x7FF83FEF, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 285   {{7, 0, 1}, DCT1,   0x60,  0x7FF83FE3, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 286   {{7, 0, 1}, DCT1,   0x64,  0x7FF83FE3, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 287   {{7, 0, 1}, DCT1,   0x68,  0x7FF83FE3, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 288   {{7, 0, 1}, DCT1,   0x6C,  0x7FF83FE3, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 289   {{7, 0, 1}, DCT1,   0x78,  0x00020000, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 290   {{7, 2, 1}, DCT1,   0x80,  0x0000FFFF, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 291   {{7, 0, 1}, DCT1,   0x84,  0x00800003, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 292   {{7, 0, 1}, DCT1,   0x88,  0x3F000000, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 293   {{7, 0, 1}, DCT1,   0x8C,  0x00070000, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 294   {{7, 0, 1}, DCT1,   0x90,  0x0BFDF102, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 295   {{7, 0, 1}, DCT1,   0xA8,  0x3F60FFBC, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 296   {{7, 0, 1}, DCT1,   0x200, 0x3F1F1F1F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 297   {{7, 0, 1}, DCT1,   0x204, 0x0F3F0F3F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 298   {{7, 0, 1}, DCT1,   0x208, 0x07070707, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 299   {{7, 2, 1}, DCT1,   0x20C, 0x00000F1F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 300   {{2, 0, 1}, DCT1,   SET_S3_NB_PSTATE_OFFSET (0x210, 0), 0xFFC7000F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 301   {{2, 0, 1}, DCT1,   SET_S3_NB_PSTATE_OFFSET (0x210, 1), 0xFFC7000F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 302   {{2, 0, 1}, DCT1,   SET_S3_NB_PSTATE_OFFSET (0x210, 2), 0xFFC7000F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 303   {{2, 0, 1}, DCT1,   SET_S3_NB_PSTATE_OFFSET (0x210, 3), 0xFFC7000F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 304   {{7, 0, 1}, DCT1,   0x214, 0x000F0F0F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 305   {{7, 0, 1}, DCT1,   0x218, 0x0F0F0F0F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 306   {{7, 0, 1}, DCT1,   0x21C, 0x001F1F00, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 307   {{7, 2, 1}, DCT1,   0x220, 0x00001F0F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 308   {{7, 2, 1}, DCT1,   0x224, 0x0000070F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 309   {{7, 0, 1}, DCT1,   0x228, 0xFFFFFFFF, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 310   {{7, 1, 1}, DCT1,   0x22C, 0x0000001F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 311   {{7, 0, 1}, DCT1,   0x230, 0x0F0F0F0F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 312   {{7, 0, 1}, DCT1,   0x234, 0x0F0F0F0F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 313   {{7, 0, 1}, DCT1,   0x238, 0x0F0F0F0F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 314   {{7, 0, 1}, DCT1,   0x23C, 0x0F0F0F0F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 315   {{7, 2, 1}, DCT1,   0x240, 0x000077FF, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 316   {{7, 1, 1}, DCT1,   0x244, 0x0000000F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 317   {{7, 0, 1}, DCT1,   0x248, 0x3F3F1F0F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 318   {{7, 0, 1}, DCT1,   0x24C, 0x3F3F3F0F, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 319
 320   // DCT 0
 321   // Phy Initialization
 322   {{5, 3, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x0B),  0, DCT0_MASK + DCT1_MASK, ANY_DIMM_MASK},
 323   {{1, 2, 1}, DCT0,   BFPllRegWaitTime, 0, DCT0_MASK, ANY_DIMM_MASK},
 324   // 3. Phy voltage related
 325   {{1, 1, 1}, DCT0,   BFDataRxVioLvl, 0x00000018, DCT0_MASK, ANY_DIMM_MASK},
 326   {{1, 1, 1}, DCT0,   BFClkRxVioLvl, 0x00000018, DCT0_MASK, ANY_DIMM_MASK},
 327   {{1, 2, 1}, DCT0,   BFCmpVioLvl, 0x0000C000, DCT0_MASK, ANY_DIMM_MASK},
 328   {{1, 1, 1}, DCT0,   BFCmdRxVioLvl, 0x00000018, DCT0_MASK, ANY_DIMM_MASK},
 329   {{1, 1, 1}, DCT0,   BFCsrComparator, 0x0000000C, DCT0_MASK, ANY_DIMM_MASK},
 330   {{1, 1, 1}, DCT0,   BFAddrRxVioLvl, 0x00000018, DCT0_MASK, ANY_DIMM_MASK},
 331   // DCT 1
 332   // Phy Initialization
 333   {{5, 3, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x0B), 0, DCT0_MASK + DCT1_MASK, ANY_DIMM_MASK},
 334   {{1, 2, 1}, DCT1,   BFPllRegWaitTime, 0, DCT1_MASK, ANY_DIMM_MASK},
 335   // 3. Phy voltage related
 336   {{1, 1, 1}, DCT1,   BFDataRxVioLvl, 0x00000018, DCT1_MASK, ANY_DIMM_MASK},
 337   {{1, 1, 1}, DCT1,   BFClkRxVioLvl, 0x00000018, DCT1_MASK, ANY_DIMM_MASK},
 338   {{1, 2, 1}, DCT1,   BFCmpVioLvl, 0x0000C000, DCT1_MASK, ANY_DIMM_MASK},
 339   {{1, 1, 1}, DCT1,   BFCmdRxVioLvl, 0x00000018, DCT1_MASK, ANY_DIMM_MASK},
 340   {{1, 1, 1}, DCT1,   BFAddrRxVioLvl, 0x00000018, DCT1_MASK, ANY_DIMM_MASK},
 341
 342   // 4. Frequency Change
 343   // Check if a channel needs to be disabled
 344   {{1, 1, 1}, DCT0,   BFCKETri, 0, DCT0_MASK + DCT1_MASK, ANY_DIMM_MASK},
 345   {{6, 3, 1}, DCT0,   0, 0, DCT0_MASK + DCT1_MASK, ANY_DIMM_MASK},
 346   {{1, 1, 1}, DCT1,   BFCKETri, 0, DCT0_MASK + DCT1_MASK, ANY_DIMM_MASK},
 347   {{6, 3, 1}, DCT1,   0, 0, DCT0_MASK + DCT1_MASK, ANY_DIMM_MASK},
 348
 349   {{3, 3, 1}, DCT0,   BFPllLockTime, 0, DCT0_MASK, ANY_DIMM_MASK},
 350   {{3, 3, 1}, DCT1,   BFPllLockTime, 0, DCT1_MASK, ANY_DIMM_MASK},
 351   {{7, 0, 1}, DCT0,   0x94,  0x0FFFEC1F, ANY_DIMM_MASK, ANY_DIMM_MASK},
 352   {{7, 0, 1}, DCT1,   0x94,  0x0FFFEC1F, ANY_DIMM_MASK, ANY_DIMM_MASK},
 353
 354   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x04), 0x003F3F3F, DCT0_MASK, ANY_DIMM_MASK},
 355   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x04), 0x003F3F3F, DCT1_MASK, ANY_DIMM_MASK},
 356   {{1, 2, 1}, DCT0,   BFProcOdtAdv, 0, DCT0_MASK, ANY_DIMM_MASK},
 357   {{1, 2, 1}, DCT1,   BFProcOdtAdv, 0, DCT1_MASK, ANY_DIMM_MASK},
 358   {{1, 2, 1}, DCT0,   BFSkewMemClk, 0, DCT0_MASK, ANY_DIMM_MASK},
 359   {{1, 2, 1}, DCT1,   BFSkewMemClk, 0, DCT1_MASK, ANY_DIMM_MASK},
 360
 361   {{9, 0, 1}, DCT0,   0x94, 0, DCT0_MASK, DCT0_ANY_DIMM_MASK},
 362   {{9, 0, 1}, DCT1,   0x94, 0, DCT1_MASK, DCT1_ANY_DIMM_MASK},
 363   {{1, 2, 1}, DCT0,   BFPllLockTime, 0, DCT0_MASK, ANY_DIMM_MASK},
 364   {{1, 2, 1}, DCT1,   BFPllLockTime, 0, DCT1_MASK, ANY_DIMM_MASK},
 365
 366   // DCT 0
 367   // 5. Phy Fence
 368   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x0C), 0x7FFF3FFF, DCT0_MASK + DCT1_MASK, ANY_DIMM_MASK},
 369   {{1, 2, 1}, DCT0,   BFDataFence2, 0x00007FFF, DCT0_MASK, ANY_DIMM_MASK},
 370   {{1, 1, 1}, DCT0,   BFClkFence2, 0x0000000F, DCT0_MASK, ANY_DIMM_MASK},
 371   {{1, 1, 1}, DCT0,   BFCmdFence2, 0x0000000F, DCT0_MASK, ANY_DIMM_MASK},
 372   {{1, 1, 1}, DCT0,   BFAddrFence2, 0x0000000F, DCT0_MASK, ANY_DIMM_MASK},
 373   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x00),  0x70777777, DCT0_MASK, ANY_DIMM_MASK},
 374
 375   // 6. Phy Compensation Init
 376   {{4, 3, 1}, DCT0,   BFDisablePredriverCal, 0, DCT0_MASK + DCT1_MASK, ANY_DIMM_MASK},
 377   {{1, 2, 1}, DCT0,   BFDataByteTxPreDriverCal2Pad1, 0, DCT0_MASK, ANY_DIMM_MASK},
 378   {{1, 2, 1}, DCT0,   BFDataByteTxPreDriverCal2Pad2, 0, DCT0_MASK, ANY_DIMM_MASK},
 379   {{8, 2, 1}, DCT0,   BFDataByteTxPreDriverCal, 0, DCT0_MASK, ANY_DIMM_MASK},
 380   {{1, 2, 1}, DCT0,   BFCmdAddr0TxPreDriverCal2Pad1, 0, DCT0_MASK, ANY_DIMM_MASK},
 381   {{1, 2, 1}, DCT0,   BFCmdAddr0TxPreDriverCal2Pad2, 0, DCT0_MASK, ANY_DIMM_MASK},
 382   {{1, 2, 1}, DCT0,   BFCmdAddr1TxPreDriverCal2Pad1, 0, DCT0_MASK, ANY_DIMM_MASK},
 383   {{1, 2, 1}, DCT0,   BFCmdAddr1TxPreDriverCal2Pad2, 0, DCT0_MASK, ANY_DIMM_MASK},
 384   {{1, 2, 1}, DCT0,   BFAddrTxPreDriverCal2Pad1, 0, DCT0_MASK, ANY_DIMM_MASK},
 385   {{1, 2, 1}, DCT0,   BFAddrTxPreDriverCal2Pad2, 0, DCT0_MASK, ANY_DIMM_MASK},
 386   {{1, 2, 1}, DCT0,   BFAddrTxPreDriverCal2Pad3, 0, DCT0_MASK, ANY_DIMM_MASK},
 387   {{1, 2, 1}, DCT0,   BFAddrTxPreDriverCal2Pad4, 0, DCT0_MASK, ANY_DIMM_MASK},
 388   {{8, 2, 1}, DCT0,   BFCmdAddr0TxPreDriverCalPad0, 0, DCT0_MASK, ANY_DIMM_MASK},
 389   {{8, 2, 1}, DCT0,   BFCmdAddr1TxPreDriverCalPad0, 0, DCT0_MASK, ANY_DIMM_MASK},
 390   {{8, 2, 1}, DCT0,   BFAddrTxPreDriverCalPad0, 0, DCT0_MASK, ANY_DIMM_MASK},
 391   {{8, 2, 1}, DCT0,   BFClock0TxPreDriverCalPad0, 0, DCT0_MASK, ANY_DIMM_MASK},
 392   {{8, 2, 1}, DCT0,   BFClock1TxPreDriverCalPad0, 0, DCT0_MASK, ANY_DIMM_MASK},
 393   {{8, 2, 1}, DCT0,   BFClock2TxPreDriverCalPad0, 0, DCT0_MASK, ANY_DIMM_MASK},
 394   // DCT 1
 395   // 5. Phy Fence
 396   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x0C), 0x7FFF0FFF, DCT1_MASK, ANY_DIMM_MASK},
 397   {{1, 2, 1}, DCT1,   BFDataFence2, 0x00007FFF, DCT1_MASK, ANY_DIMM_MASK},
 398   {{1, 1, 1}, DCT1,   BFClkFence2, 0x0000000F, DCT1_MASK, ANY_DIMM_MASK},
 399   {{1, 1, 1}, DCT1,   BFCmdFence2, 0x0000000F, DCT1_MASK, ANY_DIMM_MASK},
 400   {{1, 1, 1}, DCT1,   BFAddrFence2, 0x0000000F, DCT1_MASK, ANY_DIMM_MASK},
 401   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x00),  0x70777777, DCT1_MASK, ANY_DIMM_MASK},
 402   // 6. Phy Compensation Init
 403   {{1, 2, 1}, DCT1,   BFDataByteTxPreDriverCal2Pad1, 0, DCT1_MASK, ANY_DIMM_MASK},
 404   {{1, 2, 1}, DCT1,   BFDataByteTxPreDriverCal2Pad2, 0, DCT1_MASK, ANY_DIMM_MASK},
 405   {{8, 2, 1}, DCT1,   BFDataByteTxPreDriverCal, 0, DCT1_MASK, ANY_DIMM_MASK},
 406   {{1, 2, 1}, DCT1,   BFCmdAddr0TxPreDriverCal2Pad1, 0, DCT1_MASK, ANY_DIMM_MASK},
 407   {{1, 2, 1}, DCT1,   BFCmdAddr0TxPreDriverCal2Pad2, 0, DCT1_MASK, ANY_DIMM_MASK},
 408   {{1, 2, 1}, DCT1,   BFCmdAddr1TxPreDriverCal2Pad1, 0, DCT1_MASK, ANY_DIMM_MASK},
 409   {{1, 2, 1}, DCT1,   BFCmdAddr1TxPreDriverCal2Pad2, 0, DCT1_MASK, ANY_DIMM_MASK},
 410   {{1, 2, 1}, DCT1,   BFAddrTxPreDriverCal2Pad1, 0, DCT1_MASK, ANY_DIMM_MASK},
 411   {{1, 2, 1}, DCT1,   BFAddrTxPreDriverCal2Pad2, 0, DCT1_MASK, ANY_DIMM_MASK},
 412   {{1, 2, 1}, DCT1,   BFAddrTxPreDriverCal2Pad3, 0, DCT1_MASK, ANY_DIMM_MASK},
 413   {{1, 2, 1}, DCT1,   BFAddrTxPreDriverCal2Pad4, 0, DCT1_MASK, ANY_DIMM_MASK},
 414   {{8, 2, 1}, DCT1,   BFCmdAddr0TxPreDriverCalPad0, 0, DCT1_MASK, ANY_DIMM_MASK},
 415   {{8, 2, 1}, DCT1,   BFCmdAddr1TxPreDriverCalPad0, 0, DCT1_MASK, ANY_DIMM_MASK},
 416   {{8, 2, 1}, DCT1,   BFAddrTxPreDriverCalPad0, 0, DCT1_MASK, ANY_DIMM_MASK},
 417   {{8, 2, 1}, DCT1,   BFClock0TxPreDriverCalPad0, 0, DCT1_MASK, ANY_DIMM_MASK},
 418   {{8, 2, 1}, DCT1,   BFClock1TxPreDriverCalPad0, 0, DCT1_MASK, ANY_DIMM_MASK},
 419   {{8, 2, 1}, DCT1,   BFClock2TxPreDriverCalPad0, 0, DCT0_MASK, ANY_DIMM_MASK},
 420
 421   {{1, 2, 1}, DCT0,   BFDisablePredriverCal, 0, DCT0_MASK + DCT1_MASK, ANY_DIMM_MASK}
 422 };
 423
 424 CONST CPCI_REGISTER_BLOCK_HEADER ROMDATA S3CPciPreSelfRefOr = {
 425   0,
 426   (sizeof (S3CPciPreSelfDescriptorOr) / sizeof (CONDITIONAL_PCI_REG_DESCRIPTOR)),
 427   S3CPciPreSelfDescriptorOr,
 428   PciSpecialCaseFuncOr
 429 };
 430
 431 CONDITIONAL_PCI_REG_DESCRIPTOR ROMDATA S3CPciPostSelfDescriptorOr[] = {
 432   // DCT0 MR0 value and CS Enable map
 433   {{10, 0, 1}, DCT0, 0,  0, DCT0_MASK, ANY_DIMM_MASK},
 434   // DCT1 MR0 value and CS Enable map
 435   {{10, 0, 1}, DCT1, 0,  0, DCT1_MASK, ANY_DIMM_MASK},
 436   // DCT0
 437   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x10),  0x03FF03FF, DCT0_MASK, 0x01},
 438   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x11),  0x03FF03FF, DCT0_MASK, 0x01},
 439   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x12),  0x03FF03FF, DCT0_MASK, 0x01},
 440   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x13),  0x03FF03FF, DCT0_MASK, 0x04},
 441   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x14),  0x03FF03FF, DCT0_MASK, 0x04},
 442   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x15),  0x03FF03FF, DCT0_MASK, 0x04},
 443   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x16),  0x03FF03FF, DCT0_MASK, 0x10},
 444   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x17),  0x03FF03FF, DCT0_MASK, 0x10},
 445   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x18),  0x03FF03FF, DCT0_MASK, 0x10},
 446   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x19),  0x03FF03FF, DCT0_MASK, 0x40},
 447   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x1A),  0x03FF03FF, DCT0_MASK, 0x40},
 448   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x1B),  0x03FF03FF, DCT0_MASK, 0x40},
 449   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x20),  0x03FF03FF, DCT0_MASK, 0x01},
 450   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x21),  0x03FF03FF, DCT0_MASK, 0x01},
 451   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x23),  0x03FF03FF, DCT0_MASK, 0x04},
 452   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x24),  0x03FF03FF, DCT0_MASK, 0x04},
 453   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x26),  0x03FF03FF, DCT0_MASK, 0x10},
 454   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x27),  0x03FF03FF, DCT0_MASK, 0x10},
 455   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x29),  0x03FF03FF, DCT0_MASK, 0x40},
 456   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x2A),  0x03FF03FF, DCT0_MASK, 0x40},
 457   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x01),  0xFFFFFFFF, DCT0_MASK, 0x01},
 458   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x02),  0xFFFFFFFF, DCT0_MASK, 0x01},
 459   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x03),  0xFFFFFFFF, DCT0_MASK, 0x01},
 460   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x101), 0xFFFFFFFF, DCT0_MASK, 0x04},
 461   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x102), 0xFFFFFFFF, DCT0_MASK, 0x04},
 462   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x103), 0xFFFFFFFF, DCT0_MASK, 0x04},
 463   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x201), 0xFFFFFFFF, DCT0_MASK, 0x10},
 464   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x202), 0xFFFFFFFF, DCT0_MASK, 0x10},
 465   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x203), 0xFFFFFFFF, DCT0_MASK, 0x10},
 466   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x301), 0xFFFFFFFF, DCT0_MASK, 0x40},
 467   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x302), 0xFFFFFFFF, DCT0_MASK, 0x40},
 468   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x303), 0xFFFFFFFF, DCT0_MASK, 0x40},
 469   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x05),  0x3E3E3E3E, DCT0_MASK, 0x01},
 470   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x06),  0x3E3E3E3E, DCT0_MASK, 0x01},
 471   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x07),  0x3E3E3E3E, DCT0_MASK, 0x01},
 472   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x105), 0x3E3E3E3E, DCT0_MASK, 0x04},
 473   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x106), 0x3E3E3E3E, DCT0_MASK, 0x04},
 474   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x107), 0x3E3E3E3E, DCT0_MASK, 0x04},
 475   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x205), 0x3E3E3E3E, DCT0_MASK, 0x10},
 476   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x206), 0x3E3E3E3E, DCT0_MASK, 0x10},
 477   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x207), 0x3E3E3E3E, DCT0_MASK, 0x10},
 478   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x305), 0x3E3E3E3E, DCT0_MASK, 0x40},
 479   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x306), 0x3E3E3E3E, DCT0_MASK, 0x40},
 480   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x307), 0x3E3E3E3E, DCT0_MASK, 0x40},
 481   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x30),  0x00FF00FF, DCT0_DDR3_MASK, 0x01},
 482   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x31),  0x00FF00FF, DCT0_DDR3_MASK, 0x01},
 483   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x32),  0x00FF00FF, DCT0_DDR3_MASK, 0x01},
 484   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x33),  0x00FF00FF, DCT0_DDR3_MASK, 0x04},
 485   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x34),  0x00FF00FF, DCT0_DDR3_MASK, 0x04},
 486   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x35),  0x00FF00FF, DCT0_DDR3_MASK, 0x04},
 487   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x36),  0x00FF00FF, DCT0_DDR3_MASK, 0x10},
 488   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x37),  0x00FF00FF, DCT0_DDR3_MASK, 0x10},
 489   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x38),  0x00FF00FF, DCT0_DDR3_MASK, 0x10},
 490   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x39),  0x00FF00FF, DCT0_DDR3_MASK, 0x40},
 491   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x3A),  0x00FF00FF, DCT0_DDR3_MASK, 0x40},
 492   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x3B),  0x00FF00FF, DCT0_DDR3_MASK, 0x40},
 493   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x40),  0x00FF00FF, DCT0_DDR3_MASK, 0x01},
 494   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x41),  0x00FF00FF, DCT0_DDR3_MASK, 0x01},
 495   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x43),  0x00FF00FF, DCT0_DDR3_MASK, 0x04},
 496   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x44),  0x00FF00FF, DCT0_DDR3_MASK, 0x04},
 497   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x46),  0x00FF00FF, DCT0_DDR3_MASK, 0x10},
 498   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x47),  0x00FF00FF, DCT0_DDR3_MASK, 0x10},
 499   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x49),  0x00FF00FF, DCT0_DDR3_MASK, 0x40},
 500   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x4A),  0x00FF00FF, DCT0_DDR3_MASK, 0x40},
 501   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 0, 0x0D),  0x037F037F, DCT0_MASK, ANY_DIMM_MASK},
 502   {{1, 1, 1}, DCT0,   BFPhyClkConfig0, 0, DCT0_MASK, ANY_DIMM_MASK},
 503   {{1, 1, 1}, DCT0,   BFPhyClkConfig1, 0, DCT0_MASK, ANY_DIMM_MASK},
 504   {{1, 1, 1}, DCT0,   BFPhyClkConfig2, 0, DCT0_MASK, ANY_DIMM_MASK},
 505   {{1, 1, 1}, DCT0,   BFPhyClkConfig3, 0, DCT0_MASK, ANY_DIMM_MASK},
 506   {{1, 1, 1}, DCT0,   BFPhy0x0D0F0F13, 0x00000083, DCT0_MASK, ANY_DIMM_MASK},
 507   {{1, 1, 1}, DCT0,   BFAddrCmdTri, 0x0000000A1, DCT0_MASK, ANY_DIMM_MASK},
 508   {{1, 2, 1}, DCT0,   BFReserved00C, 0, DCT0_MASK, ANY_DIMM_MASK},
 509   {{1, 2, 1}, DCT0,   BFEnRxPadStandby, 0, DCT0_MASK, ANY_DIMM_MASK},
 510   {{1, 1, 1}, DCT0,   BFEccDLLPwrDnConf, 0, DCT0_MASK, ANY_DIMM_MASK},
 511   {{1, 2, 1}, DCT0,   BFTriDM, 0, DCT0_MASK, ANY_DIMM_MASK},
 512   {{1, 1, 1}, DCT0,   BFDisDllShutdownSR, 0x00000001, DCT0_MASK, ANY_DIMM_MASK},
 513   {{1, 1, 1}, DCT0,   BFReserved4_0,  0x0000001F, DCT0_MASK, 0x01},
 514   {{1, 2, 1}, DCT0,   BFReserved4_1,  0x00001F00, DCT0_MASK, 0x01},
 515   {{1, 1, 1}, DCT0,   BFReserved4_2,  0x0000001F, DCT0_MASK, 0x01},
 516   {{1, 2, 1}, DCT0,   BFReserved4_3,  0x00001F00, DCT0_MASK, 0x01},
 517   {{1, 1, 1}, DCT0,   BFReserved4_4,  0x0000001F, DCT0_MASK, 0x01},
 518   {{1, 2, 1}, DCT0,   BFReserved4_5,  0x00001F00, DCT0_MASK, 0x01},
 519   {{1, 1, 1}, DCT0,   BFReserved4_6,  0x0000001F, DCT0_MASK, 0x01},
 520   {{1, 2, 1}, DCT0,   BFReserved4_7,  0x00001F00, DCT0_MASK, 0x01},
 521   {{1, 1, 1}, DCT0,   BFReserved4_8,  0x0000001F, DCT0_MASK, 0x01},
 522   {{1, 2, 1}, DCT0,   BFReserved4_9,  0x00001F00, DCT0_MASK, 0x01},
 523   {{1, 1, 1}, DCT0,   BFReserved4_A,  0x0000001F, DCT0_MASK, 0x01},
 524   {{1, 2, 1}, DCT0,   BFReserved4_B,  0x00001F00, DCT0_MASK, 0x01},
 525   {{1, 1, 1}, DCT0,   BFReserved4_C,  0x0000001F, DCT0_MASK, 0x01},
 526   {{1, 2, 1}, DCT0,   BFReserved4_D,  0x00001F00, DCT0_MASK, 0x01},
 527   {{1, 1, 1}, DCT0,   BFReserved4_E,  0x0000001F, DCT0_MASK, 0x01},
 528   {{1, 2, 1}, DCT0,   BFReserved4_F,  0x00001F00, DCT0_MASK, 0x01},
 529   {{1, 1, 1}, DCT0,   BFReserved4_10, 0x0000001F, DCT0_MASK, 0x01},
 530   {{1, 2, 1}, DCT0,   BFReserved4_11, 0x00001F00, DCT0_MASK, 0x01},
 531   {{1, 1, 1}, DCT0,   BFReserved5_0,  0x0000001F, DCT0_MASK, 0x04},
 532   {{1, 2, 1}, DCT0,   BFReserved5_1,  0x00001F00, DCT0_MASK, 0x04},
 533   {{1, 1, 1}, DCT0,   BFReserved5_2,  0x0000001F, DCT0_MASK, 0x04},
 534   {{1, 2, 1}, DCT0,   BFReserved5_3,  0x00001F00, DCT0_MASK, 0x04},
 535   {{1, 1, 1}, DCT0,   BFReserved5_4,  0x0000001F, DCT0_MASK, 0x04},
 536   {{1, 2, 1}, DCT0,   BFReserved5_5,  0x00001F00, DCT0_MASK, 0x04},
 537   {{1, 1, 1}, DCT0,   BFReserved5_6,  0x0000001F, DCT0_MASK, 0x04},
 538   {{1, 2, 1}, DCT0,   BFReserved5_7,  0x00001F00, DCT0_MASK, 0x04},
 539   {{1, 1, 1}, DCT0,   BFReserved5_8,  0x0000001F, DCT0_MASK, 0x04},
 540   {{1, 2, 1}, DCT0,   BFReserved5_9,  0x00001F00, DCT0_MASK, 0x04},
 541   {{1, 1, 1}, DCT0,   BFReserved5_A,  0x0000001F, DCT0_MASK, 0x04},
 542   {{1, 2, 1}, DCT0,   BFReserved5_B,  0x00001F00, DCT0_MASK, 0x04},
 543   {{1, 1, 1}, DCT0,   BFReserved5_C,  0x0000001F, DCT0_MASK, 0x04},
 544   {{1, 2, 1}, DCT0,   BFReserved5_D,  0x00001F00, DCT0_MASK, 0x04},
 545   {{1, 1, 1}, DCT0,   BFReserved5_E,  0x0000001F, DCT0_MASK, 0x04},
 546   {{1, 2, 1}, DCT0,   BFReserved5_F,  0x00001F00, DCT0_MASK, 0x04},
 547   {{1, 1, 1}, DCT0,   BFReserved5_10, 0x0000001F, DCT0_MASK, 0x04},
 548   {{1, 2, 1}, DCT0,   BFReserved5_11, 0x00001F00, DCT0_MASK, 0x04},
 549   {{1, 1, 1}, DCT0,   BFReserved6_0,  0x0000001F, DCT0_MASK, 0x10},
 550   {{1, 2, 1}, DCT0,   BFReserved6_1,  0x00001F00, DCT0_MASK, 0x10},
 551   {{1, 1, 1}, DCT0,   BFReserved6_2,  0x0000001F, DCT0_MASK, 0x10},
 552   {{1, 2, 1}, DCT0,   BFReserved6_3,  0x00001F00, DCT0_MASK, 0x10},
 553   {{1, 1, 1}, DCT0,   BFReserved6_4,  0x0000001F, DCT0_MASK, 0x10},
 554   {{1, 2, 1}, DCT0,   BFReserved6_5,  0x00001F00, DCT0_MASK, 0x10},
 555   {{1, 1, 1}, DCT0,   BFReserved6_6,  0x0000001F, DCT0_MASK, 0x10},
 556   {{1, 2, 1}, DCT0,   BFReserved6_7,  0x00001F00, DCT0_MASK, 0x10},
 557   {{1, 1, 1}, DCT0,   BFReserved6_8,  0x0000001F, DCT0_MASK, 0x10},
 558   {{1, 2, 1}, DCT0,   BFReserved6_9,  0x00001F00, DCT0_MASK, 0x10},
 559   {{1, 1, 1}, DCT0,   BFReserved6_A,  0x0000001F, DCT0_MASK, 0x10},
 560   {{1, 2, 1}, DCT0,   BFReserved6_B,  0x00001F00, DCT0_MASK, 0x10},
 561   {{1, 1, 1}, DCT0,   BFReserved6_C,  0x0000001F, DCT0_MASK, 0x10},
 562   {{1, 2, 1}, DCT0,   BFReserved6_D,  0x00001F00, DCT0_MASK, 0x10},
 563   {{1, 1, 1}, DCT0,   BFReserved6_E,  0x0000001F, DCT0_MASK, 0x10},
 564   {{1, 2, 1}, DCT0,   BFReserved6_F,  0x00001F00, DCT0_MASK, 0x10},
 565   {{1, 1, 1}, DCT0,   BFReserved6_10, 0x0000001F, DCT0_MASK, 0x10},
 566   {{1, 2, 1}, DCT0,   BFReserved6_11, 0x00001F00, DCT0_MASK, 0x10},
 567   {{1, 1, 1}, DCT0,   BFReserved7_0,  0x0000001F, DCT0_MASK, 0x40},
 568   {{1, 2, 1}, DCT0,   BFReserved7_1,  0x00001F00, DCT0_MASK, 0x40},
 569   {{1, 1, 1}, DCT0,   BFReserved7_2,  0x0000001F, DCT0_MASK, 0x40},
 570   {{1, 2, 1}, DCT0,   BFReserved7_3,  0x00001F00, DCT0_MASK, 0x40},
 571   {{1, 1, 1}, DCT0,   BFReserved7_4,  0x0000001F, DCT0_MASK, 0x40},
 572   {{1, 2, 1}, DCT0,   BFReserved7_5,  0x00001F00, DCT0_MASK, 0x40},
 573   {{1, 1, 1}, DCT0,   BFReserved7_6,  0x0000001F, DCT0_MASK, 0x40},
 574   {{1, 2, 1}, DCT0,   BFReserved7_7,  0x00001F00, DCT0_MASK, 0x40},
 575   {{1, 1, 1}, DCT0,   BFReserved7_8,  0x0000001F, DCT0_MASK, 0x40},
 576   {{1, 2, 1}, DCT0,   BFReserved7_9,  0x00001F00, DCT0_MASK, 0x40},
 577   {{1, 1, 1}, DCT0,   BFReserved7_A,  0x0000001F, DCT0_MASK, 0x40},
 578   {{1, 1, 1}, DCT0,   BFReserved7_B,  0x00001F00, DCT0_MASK, 0x40},
 579   {{1, 2, 1}, DCT0,   BFReserved7_C,  0x0000001F, DCT0_MASK, 0x40},
 580   {{1, 1, 1}, DCT0,   BFReserved7_D,  0x00001F00, DCT0_MASK, 0x40},
 581   {{1, 2, 1}, DCT0,   BFReserved7_E,  0x0000001F, DCT0_MASK, 0x40},
 582   {{1, 1, 1}, DCT0,   BFReserved7_F,  0x00001F00, DCT0_MASK, 0x40},
 583   {{1, 2, 1}, DCT0,   BFReserved7_10, 0x0000001F, DCT0_MASK, 0x40},
 584   {{1, 1, 1}, DCT0,   BFReserved7_11, 0x00001F00, DCT0_MASK, 0x40},
 585   {{1, 1, 1}, DCT0,   BFReserved8_0, 0x00000003, DCT0_MASK, ANY_DIMM_MASK},
 586   {{1, 1, 1}, DCT0,   BFReserved8_1, 0x0000007C, DCT0_MASK, ANY_DIMM_MASK},
 587
 588     // DCT1
 589   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x10),  0x03FF03FF, DCT1_MASK, 0x02},
 590   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x11),  0x03FF03FF, DCT1_MASK, 0x02},
 591   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x12),  0x03FF03FF, DCT1_MASK, 0x02},
 592   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x13),  0x03FF03FF, DCT1_MASK, 0x08},
 593   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x14),  0x03FF03FF, DCT1_MASK, 0x08},
 594   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x15),  0x03FF03FF, DCT1_MASK, 0x08},
 595   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x16),  0x03FF03FF, DCT1_MASK, 0x20},
 596   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x17),  0x03FF03FF, DCT1_MASK, 0x20},
 597   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x18),  0x03FF03FF, DCT1_MASK, 0x20},
 598   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x19),  0x03FF03FF, DCT1_MASK, 0x80},
 599   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x1A),  0x03FF03FF, DCT1_MASK, 0x80},
 600   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x1B),  0x03FF03FF, DCT1_MASK, 0x80},
 601   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x20),  0x03FF03FF, DCT1_MASK, 0x02},
 602   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x21),  0x03FF03FF, DCT1_MASK, 0x02},
 603   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x23),  0x03FF03FF, DCT1_MASK, 0x08},
 604   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x24),  0x03FF03FF, DCT1_MASK, 0x08},
 605   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x26),  0x03FF03FF, DCT1_MASK, 0x20},
 606   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x27),  0x03FF03FF, DCT1_MASK, 0x20},
 607   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x29),  0x03FF03FF, DCT1_MASK, 0x80},
 608   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x2A),  0x03FF03FF, DCT1_MASK, 0x80},
 609   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x01),  0xFFFFFFFF, DCT1_MASK, 0x02},
 610   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x02),  0xFFFFFFFF, DCT1_MASK, 0x02},
 611   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x03),  0xFFFFFFFF, DCT1_MASK, 0x02},
 612   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x101), 0xFFFFFFFF, DCT1_MASK, 0x08},
 613   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x102), 0xFFFFFFFF, DCT1_MASK, 0x08},
 614   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x103), 0xFFFFFFFF, DCT1_MASK, 0x08},
 615   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x201), 0xFFFFFFFF, DCT1_MASK, 0x10},
 616   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x202), 0xFFFFFFFF, DCT1_MASK, 0x10},
 617   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x203), 0xFFFFFFFF, DCT1_MASK, 0x10},
 618   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x301), 0xFFFFFFFF, DCT1_MASK, 0x80},
 619   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x302), 0xFFFFFFFF, DCT1_MASK, 0x80},
 620   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x303), 0xFFFFFFFF, DCT1_MASK, 0x80},
 621   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x05),  0x3E3E3E3E, DCT1_MASK, 0x02},
 622   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x06),  0x3E3E3E3E, DCT1_MASK, 0x02},
 623   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x07),  0x3E3E3E3E, DCT1_MASK, 0x02},
 624   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x105), 0x3E3E3E3E, DCT1_MASK, 0x08},
 625   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x106), 0x3E3E3E3E, DCT1_MASK, 0x08},
 626   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x107), 0x3E3E3E3E, DCT1_MASK, 0x08},
 627   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x205), 0x3E3E3E3E, DCT1_MASK, 0x20},
 628   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x206), 0x3E3E3E3E, DCT1_MASK, 0x20},
 629   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x207), 0x3E3E3E3E, DCT1_MASK, 0x20},
 630   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x305), 0x3E3E3E3E, DCT1_MASK, 0x80},
 631   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x306), 0x3E3E3E3E, DCT1_MASK, 0x80},
 632   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x307), 0x3E3E3E3E, DCT1_MASK, 0x80},
 633   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x30),  0x00FF00FF, DCT1_DDR3_MASK, 0x02},
 634   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x31),  0x00FF00FF, DCT1_DDR3_MASK, 0x02},
 635   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x32),  0x00FF00FF, DCT1_DDR3_MASK, 0x02},
 636   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x33),  0x00FF00FF, DCT1_DDR3_MASK, 0x08},
 637   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x34),  0x00FF00FF, DCT1_DDR3_MASK, 0x08},
 638   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x35),  0x00FF00FF, DCT1_DDR3_MASK, 0x08},
 639   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x36),  0x00FF00FF, DCT1_DDR3_MASK, 0x20},
 640   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x37),  0x00FF00FF, DCT1_DDR3_MASK, 0x20},
 641   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x38),  0x00FF00FF, DCT1_DDR3_MASK, 0x20},
 642   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x39),  0x00FF00FF, DCT1_DDR3_MASK, 0x80},
 643   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x3A),  0x00FF00FF, DCT1_DDR3_MASK, 0x80},
 644   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x3B),  0x00FF00FF, DCT1_DDR3_MASK, 0x80},
 645   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x40),  0x00FF00FF, DCT1_DDR3_MASK, 0x02},
 646   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x41),  0x00FF00FF, DCT1_DDR3_MASK, 0x02},
 647   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x43),  0x00FF00FF, DCT1_DDR3_MASK, 0x08},
 648   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x44),  0x00FF00FF, DCT1_DDR3_MASK, 0x08},
 649   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x46),  0x00FF00FF, DCT1_DDR3_MASK, 0x20},
 650   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x47),  0x00FF00FF, DCT1_DDR3_MASK, 0x20},
 651   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x49),  0x00FF00FF, DCT1_DDR3_MASK, 0x80},
 652   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x4A),  0x00FF00FF, DCT1_DDR3_MASK, 0x80},
 653   {{0, 0, 1}, FUNC_2, SET_S3_SPECIAL_OFFSET (DCT_PHY_FLAG, 1, 0x0D),  0x037F037F, DCT1_MASK, ANY_DIMM_MASK},
 654   {{1, 1, 1}, DCT1,   BFPhyClkConfig0, 0, DCT1_MASK, ANY_DIMM_MASK},
 655   {{1, 1, 1}, DCT1,   BFPhyClkConfig1, 0, DCT1_MASK, ANY_DIMM_MASK},
 656   {{1, 1, 1}, DCT1,   BFPhyClkConfig2, 0, DCT1_MASK, ANY_DIMM_MASK},
 657   {{1, 1, 1}, DCT1,   BFPhyClkConfig3, 0, DCT1_MASK, ANY_DIMM_MASK},
 658   {{1, 1, 1}, DCT1,   BFPhy0x0D0F0F13, 0x00000083, DCT1_MASK, ANY_DIMM_MASK},
 659   {{1, 1, 1}, DCT1,   BFAddrCmdTri, 0x0000000A1, DCT1_MASK, ANY_DIMM_MASK},
 660   {{1, 2, 1}, DCT1,   BFReserved00C, 0, DCT1_MASK, ANY_DIMM_MASK},
 661   {{1, 2, 1}, DCT1,   BFEnRxPadStandby, 0, DCT1_MASK, ANY_DIMM_MASK},
 662   {{1, 1, 1}, DCT1,   BFEccDLLPwrDnConf, 0, DCT1_MASK, ANY_DIMM_MASK},
 663   {{1, 2, 1}, DCT1,   BFTriDM, 0, DCT1_MASK, ANY_DIMM_MASK},
 664   {{1, 1, 1}, DCT1,   BFDisDllShutdownSR, 0, DCT1_MASK, ANY_DIMM_MASK},
 665   {{1, 1, 1}, DCT1,   BFReserved4_0,  0x0000001F, DCT1_MASK, 0x02},
 666   {{1, 2, 1}, DCT1,   BFReserved4_1,  0x00001F00, DCT1_MASK, 0x02},
 667   {{1, 1, 1}, DCT1,   BFReserved4_2,  0x0000001F, DCT1_MASK, 0x02},
 668   {{1, 2, 1}, DCT1,   BFReserved4_3,  0x00001F00, DCT1_MASK, 0x02},
 669   {{1, 1, 1}, DCT1,   BFReserved4_4,  0x0000001F, DCT1_MASK, 0x02},
 670   {{1, 2, 1}, DCT1,   BFReserved4_5,  0x00001F00, DCT1_MASK, 0x02},
 671   {{1, 1, 1}, DCT1,   BFReserved4_6,  0x0000001F, DCT1_MASK, 0x02},
 672   {{1, 2, 1}, DCT1,   BFReserved4_7,  0x00001F00, DCT1_MASK, 0x02},
 673   {{1, 1, 1}, DCT1,   BFReserved4_8,  0x0000001F, DCT1_MASK, 0x02},
 674   {{1, 2, 1}, DCT1,   BFReserved4_9,  0x00001F00, DCT1_MASK, 0x02},
 675   {{1, 1, 1}, DCT1,   BFReserved4_A,  0x0000001F, DCT1_MASK, 0x02},
 676   {{1, 2, 1}, DCT1,   BFReserved4_B,  0x00001F00, DCT1_MASK, 0x02},
 677   {{1, 1, 1}, DCT1,   BFReserved4_C,  0x0000001F, DCT1_MASK, 0x02},
 678   {{1, 2, 1}, DCT1,   BFReserved4_D,  0x00001F00, DCT1_MASK, 0x02},
 679   {{1, 1, 1}, DCT1,   BFReserved4_E,  0x0000001F, DCT1_MASK, 0x02},
 680   {{1, 2, 1}, DCT1,   BFReserved4_F,  0x00001F00, DCT1_MASK, 0x02},
 681   {{1, 1, 1}, DCT1,   BFReserved4_10, 0x0000001F, DCT1_MASK, 0x02},
 682   {{1, 2, 1}, DCT1,   BFReserved4_11, 0x00001F00, DCT1_MASK, 0x02},
 683   {{1, 1, 1}, DCT1,   BFReserved5_0,  0x0000001F, DCT1_MASK, 0x08},
 684   {{1, 2, 1}, DCT1,   BFReserved5_1,  0x00001F00, DCT1_MASK, 0x08},
 685   {{1, 1, 1}, DCT1,   BFReserved5_2,  0x0000001F, DCT1_MASK, 0x08},
 686   {{1, 2, 1}, DCT1,   BFReserved5_3,  0x00001F00, DCT1_MASK, 0x08},
 687   {{1, 1, 1}, DCT1,   BFReserved5_4,  0x0000001F, DCT1_MASK, 0x08},
 688   {{1, 2, 1}, DCT1,   BFReserved5_5,  0x00001F00, DCT1_MASK, 0x08},
 689   {{1, 1, 1}, DCT1,   BFReserved5_6,  0x0000001F, DCT1_MASK, 0x08},
 690   {{1, 2, 1}, DCT1,   BFReserved5_7,  0x00001F00, DCT1_MASK, 0x08},
 691   {{1, 1, 1}, DCT1,   BFReserved5_8,  0x0000001F, DCT1_MASK, 0x08},
 692   {{1, 2, 1}, DCT1,   BFReserved5_9,  0x00001F00, DCT1_MASK, 0x08},
 693   {{1, 1, 1}, DCT1,   BFReserved5_A,  0x0000001F, DCT1_MASK, 0x08},
 694   {{1, 2, 1}, DCT1,   BFReserved5_B,  0x00001F00, DCT1_MASK, 0x08},
 695   {{1, 1, 1}, DCT1,   BFReserved5_C,  0x0000001F, DCT1_MASK, 0x08},
 696   {{1, 2, 1}, DCT1,   BFReserved5_D,  0x00001F00, DCT1_MASK, 0x08},
 697   {{1, 1, 1}, DCT1,   BFReserved5_E,  0x0000001F, DCT1_MASK, 0x08},
 698   {{1, 2, 1}, DCT1,   BFReserved5_F,  0x00001F00, DCT1_MASK, 0x08},
 699   {{1, 1, 1}, DCT1,   BFReserved5_10, 0x0000001F, DCT1_MASK, 0x08},
 700   {{1, 2, 1}, DCT1,   BFReserved5_11, 0x00001F00, DCT1_MASK, 0x08},
 701   {{1, 1, 1}, DCT1,   BFReserved6_0,  0x0000001F, DCT1_MASK, 0x20},
 702   {{1, 2, 1}, DCT1,   BFReserved6_1,  0x00001F00, DCT1_MASK, 0x20},
 703   {{1, 1, 1}, DCT1,   BFReserved6_2,  0x0000001F, DCT1_MASK, 0x20},
 704   {{1, 2, 1}, DCT1,   BFReserved6_3,  0x00001F00, DCT1_MASK, 0x20},
 705   {{1, 1, 1}, DCT1,   BFReserved6_4,  0x0000001F, DCT1_MASK, 0x20},
 706   {{1, 2, 1}, DCT1,   BFReserved6_5,  0x00001F00, DCT1_MASK, 0x20},
 707   {{1, 1, 1}, DCT1,   BFReserved6_6,  0x0000001F, DCT1_MASK, 0x20},
 708   {{1, 2, 1}, DCT1,   BFReserved6_7,  0x00001F00, DCT1_MASK, 0x20},
 709   {{1, 1, 1}, DCT1,   BFReserved6_8,  0x0000001F, DCT1_MASK, 0x20},
 710   {{1, 2, 1}, DCT1,   BFReserved6_9,  0x00001F00, DCT1_MASK, 0x20},
 711   {{1, 1, 1}, DCT1,   BFReserved6_A,  0x0000001F, DCT1_MASK, 0x20},
 712   {{1, 2, 1}, DCT1,   BFReserved6_B,  0x00001F00, DCT1_MASK, 0x20},
 713   {{1, 1, 1}, DCT1,   BFReserved6_C,  0x0000001F, DCT1_MASK, 0x20},
 714   {{1, 2, 1}, DCT1,   BFReserved6_D,  0x00001F00, DCT1_MASK, 0x20},
 715   {{1, 1, 1}, DCT1,   BFReserved6_E,  0x0000001F, DCT1_MASK, 0x20},
 716   {{1, 2, 1}, DCT1,   BFReserved6_F,  0x00001F00, DCT1_MASK, 0x20},
 717   {{1, 1, 1}, DCT1,   BFReserved6_10, 0x0000001F, DCT1_MASK, 0x20},
 718   {{1, 2, 1}, DCT1,   BFReserved6_11, 0x00001F00, DCT1_MASK, 0x20},
 719   {{1, 1, 1}, DCT1,   BFReserved7_0,  0x0000001F, DCT1_MASK, 0x80},
 720   {{1, 2, 1}, DCT1,   BFReserved7_1,  0x00001F00, DCT1_MASK, 0x80},
 721   {{1, 1, 1}, DCT1,   BFReserved7_2,  0x0000001F, DCT1_MASK, 0x80},
 722   {{1, 2, 1}, DCT1,   BFReserved7_3,  0x00001F00, DCT1_MASK, 0x80},
 723   {{1, 1, 1}, DCT1,   BFReserved7_4,  0x0000001F, DCT1_MASK, 0x80},
 724   {{1, 2, 1}, DCT1,   BFReserved7_5,  0x00001F00, DCT1_MASK, 0x80},
 725   {{1, 1, 1}, DCT1,   BFReserved7_6,  0x0000001F, DCT1_MASK, 0x80},
 726   {{1, 2, 1}, DCT1,   BFReserved7_7,  0x00001F00, DCT1_MASK, 0x80},
 727   {{1, 1, 1}, DCT1,   BFReserved7_8,  0x0000001F, DCT1_MASK, 0x80},
 728   {{1, 2, 1}, DCT1,   BFReserved7_9,  0x00001F00, DCT1_MASK, 0x80},
 729   {{1, 1, 1}, DCT1,   BFReserved7_A,  0x0000001F, DCT1_MASK, 0x80},
 730   {{1, 1, 1}, DCT1,   BFReserved7_B,  0x00001F00, DCT1_MASK, 0x80},
 731   {{1, 2, 1}, DCT1,   BFReserved7_C,  0x0000001F, DCT1_MASK, 0x80},
 732   {{1, 1, 1}, DCT1,   BFReserved7_D,  0x00001F00, DCT1_MASK, 0x80},
 733   {{1, 2, 1}, DCT1,   BFReserved7_E,  0x0000001F, DCT1_MASK, 0x80},
 734   {{1, 1, 1}, DCT1,   BFReserved7_F,  0x00001F00, DCT1_MASK, 0x80},
 735   {{1, 2, 1}, DCT1,   BFReserved7_10, 0x0000001F, DCT1_MASK, 0x80},
 736   {{1, 1, 1}, DCT1,   BFReserved7_11, 0x00001F00, DCT1_MASK, 0x80},
 737   {{1, 1, 1}, DCT1,   BFReserved8_0, 0x00000003, DCT1_MASK, ANY_DIMM_MASK},
 738   {{1, 1, 1}, DCT1,   BFReserved8_1, 0x0000007C, DCT1_MASK, ANY_DIMM_MASK},
 739
 740   {{0, 0, 0}, FUNC_2, 0x1B4, 0x08000000, ANY_DIMM_MASK, ANY_DIMM_MASK},
 741   {{0, 0, 0}, FUNC_3, 0x180, 0x02000000, ANY_DIMM_MASK, ANY_DIMM_MASK},
 742   {{0, 0, 0}, FUNC_3, 0x58,  0x1F00001F, ANY_DIMM_MASK, ANY_DIMM_MASK},
 743   {{0, 0, 0}, FUNC_3, 0x5C,  0x00000001, ANY_DIMM_MASK, ANY_DIMM_MASK},
 744   {{0, 0, 0}, FUNC_3, 0x80,  0xE7E7E7E7, ANY_DIMM_MASK, ANY_DIMM_MASK},
 745   {{0, 0, 0}, FUNC_3, 0x84,  0xE7E7E7E7, ANY_DIMM_MASK, ANY_DIMM_MASK},
 746   {{0, 0, 0}, FUNC_3, 0x1B8, 0x00000010, ANY_DIMM_MASK, ANY_DIMM_MASK},
 747   {{0, 0, 0}, FUNC_3, 0x44,  0x00400004, ANY_DIMM_MASK, ANY_DIMM_MASK},
 748   {{0, 0, 0}, FUNC_4, 0x128, 0x0003F000, ANY_DIMM_MASK, ANY_DIMM_MASK},
 749   // Release NB P-state force
 750   {{0, 2, 0}, FUNC_5, 0x170, 0x00006EDB, ANY_DIMM_MASK, ANY_DIMM_MASK},
 751   {{0, 0, 0}, FUNC_2, 0x118, 0x00040000, ANY_DIMM_MASK, ANY_DIMM_MASK},
 752   {{0, 0, 0}, FUNC_2, 0x118, 0x00080000, ANY_DIMM_MASK, ANY_DIMM_MASK},
 753 };
 754
 755 CONST CPCI_REGISTER_BLOCK_HEADER ROMDATA S3CPciPostSelfRefOr = {
 756   0,
 757   (sizeof (S3CPciPostSelfDescriptorOr) / sizeof (CONDITIONAL_PCI_REG_DESCRIPTOR)),
 758   S3CPciPostSelfDescriptorOr,
 759   PciSpecialCaseFuncOr
 760 };
 761
 762 MSR_REG_DESCRIPTOR ROMDATA S3MSRPreSelfRefDescriptorOr[] = {
 763   {{0, 0, 0}, 0xC0010010, 0x00000000007F0000},
 764   {{0, 0, 0}, 0xC001001A, 0x0000FFFFFF800000},
 765   {{0, 0, 0}, 0xC001001D, 0x0000FFFFFF800000},
 766   {{0, 0, 0}, 0xC001001F, 0x0044601080000600}
 767 };
 768
 769 CONST MSR_REGISTER_BLOCK_HEADER ROMDATA S3MSRPreSelfRefOr = {
 770   0,
 771   (sizeof (S3MSRPreSelfRefDescriptorOr) / sizeof (MSR_REG_DESCRIPTOR)),
 772   S3MSRPreSelfRefDescriptorOr,
 773   NULL
 774 };
 775
 776 VOID *MemS3RegListOr[] = {
 777   (VOID *)&S3PciPreSelfRefOr,
 778   NULL,
 779   (VOID *)&S3CPciPreSelfRefOr,
 780   (VOID *)&S3CPciPostSelfRefOr,
 781   (VOID *)&S3MSRPreSelfRefOr,
 782   NULL,
 783   NULL,
 784   NULL
 785 };
 786
 787 /*----------------------------------------------------------------------------
 788  *                            EXPORTED FUNCTIONS
 789  *
 790  *----------------------------------------------------------------------------
 791  */
 792 /* -----------------------------------------------------------------------------*/
 793 /**
 794  *
 795  *
 796  *   This function initializes the northbridge block for S3 resume
 797  *
 798  *     @param[in,out]   *S3NBPtr   - Pointer to MEM_NB_BLOCK.
 799  *     @param[in,out]   *MemPtr  - Pointer to MEM_DATA_STRUCT.
 800  *     @param[in]       NodeID   - Node ID of the target node.
 801  *
 802  *      @return         BOOLEAN
 803  *                         TRUE - This is the correct constructor for the targeted node.
 804  *                         FALSE - This isn't the correct constructor for the targeted node.
 805  */
 806 BOOLEAN
 807 MemS3ResumeConstructNBBlockOr (
 808   IN OUT   VOID *S3NBPtr,
 809   IN OUT   MEM_DATA_STRUCT *MemPtr,
 810   IN       UINT8 NodeID
 811   )
 812 {
 813   UINT32  PackageType;
 814   INT32 i;
 815   MEM_NB_BLOCK *NBPtr;
 816
 817   NBPtr = ((S3_MEM_NB_BLOCK *)S3NBPtr)->NBPtr;
 818
 819   //
 820   // Determine if this is the expected NB Type
 821   //
 822   GetLogicalIdOfSocket (MemPtr->DiesPerSystem[NodeID].SocketId, &(MemPtr->DiesPerSystem[NodeID].LogicalCpuid), &(MemPtr->StdHeader));
 823   if (!MemNIsIdSupportedOr (NBPtr, &(MemPtr->DiesPerSystem[NodeID].LogicalCpuid))) {
 824     return FALSE;
 825   }
 826
 827   NBPtr->MemPtr = MemPtr;
 828   NBPtr->MCTPtr = &(MemPtr->DiesPerSystem[NodeID]);
 829   NBPtr->PciAddr.AddressValue = MemPtr->DiesPerSystem[NodeID].PciAddr.AddressValue;
 830   MemNInitNBRegTableOr (NBPtr, NBPtr->NBRegTable);
 831   NBPtr->Node = ((UINT8) NBPtr->PciAddr.Address.Device) - 24;
 832   NBPtr->Dct = 0;
 833   NBPtr->Channel = 0;
 834   NBPtr->Ganged = FALSE;
 835   NBPtr->NodeCount = MAX_NODES_SUPPORTED_OR;
 836   NBPtr->DctCount = MAX_DCTS_PER_NODE_OR;
 837
 838   for (i = 0; i < EnumSize; i++) {
 839     NBPtr->IsSupported[i] = FALSE;
 840   }
 841
 842   for (i = 0; i < NumberOfHooks; i++) {
 843     NBPtr->FamilySpecificHook[i] = (BOOLEAN (*) (MEM_NB_BLOCK *, VOID *)) memDefTrue;
 844   }
 845
 846   LibAmdMemFill (NBPtr->DctCache, 0, sizeof (NBPtr->DctCache), &MemPtr->StdHeader);
 847
 848   NBPtr->SwitchDCT = MemNSwitchDCTNb;
 849   NBPtr->SwitchChannel = MemNSwitchChannelNb;
 850   NBPtr->MemNCmnGetSetFieldNb = MemNCmnGetSetFieldOr;
 851   NBPtr->GetBitField = MemNGetBitFieldNb;
 852   NBPtr->SetBitField = MemNSetBitFieldNb;
 853   NBPtr->MemNIsIdSupportedNb = MemNIsIdSupportedOr;
 854   ((S3_MEM_NB_BLOCK *)S3NBPtr)->MemS3ExitSelfRefReg = (VOID (*) (MEM_NB_BLOCK *, AMD_CONFIG_PARAMS *)) memDefRet;
 855   ((S3_MEM_NB_BLOCK *)S3NBPtr)->MemS3GetConPCIMask = MemNS3GetConPCIMaskUnb;
 856   ((S3_MEM_NB_BLOCK *)S3NBPtr)->MemS3GetConMSRMask = (VOID (*) (MEM_NB_BLOCK *, DESCRIPTOR_GROUP *)) memDefRet;
 857   ((S3_MEM_NB_BLOCK *)S3NBPtr)->MemS3Resume = MemNS3ResumeUNb;
 858   ((S3_MEM_NB_BLOCK *)S3NBPtr)->MemS3RestoreScrub = MemNS3RestoreScrubNb;
 859   ((S3_MEM_NB_BLOCK *)S3NBPtr)->MemS3GetRegLstPtr = MemNS3GetRegLstPtrOr;
 860   ((S3_MEM_NB_BLOCK *)S3NBPtr)->MemS3GetDeviceRegLst = MemNS3GetDeviceRegLstOr;
 861   ((S3_MEM_NB_BLOCK *)S3NBPtr)->MemS3SpecialCaseHeapSize = 0;
 862   NBPtr->FamilySpecificHook[DCTSelectSwitch] = MemNS3DctCfgSelectUnb;
 863
 864   // AM3r2 does not support Dll shutdown
 865   PackageType = LibAmdGetPackageType (&(NBPtr->MemPtr->StdHeader));
 866   if (PackageType != PACKAGE_TYPE_AM3r2) {
 867     NBPtr->IsSupported[SetDllShutDown] = TRUE;
 868   }
 869
 870   return TRUE;
 871 }
 872
 873 /*----------------------------------------------------------------------------
 874  *                              LOCAL FUNCTIONS
 875  *
 876  *----------------------------------------------------------------------------*/
 877 /* -----------------------------------------------------------------------------*/
 878 /**
 879  *
 880  *
 881  *   This function returns the register list for each device for OR
 882  *
 883  *     @param[in,out]   *NBPtr   - Pointer to the MEM_NB_BLOCK
 884  *     @param[in, out]  *DescriptPtr - Pointer to DESCRIPTOR_GROUP
 885  *     @return          UINT16 - size of the device descriptor on the target node.
 886  */
 887 UINT16
 888 STATIC
 889 MemNS3GetRegLstPtrOr (
 890   IN OUT   MEM_NB_BLOCK *NBPtr,
 891   IN OUT   DESCRIPTOR_GROUP *DescriptPtr
 892   )
 893 {
 894   UINT8 i;
 895   UINT16 Size;
 896   Size = 0;
 897   for (i = PRESELFREF; i <= POSTSELFREF; i ++) {
 898     DescriptPtr->PCIDevice[i].Type = (UINT8) (DEV_TYPE_PCI_PRE_ESR + i);
 899     DescriptPtr->PCIDevice[i].Node = NBPtr->Node;
 900     DescriptPtr->PCIDevice[i].RegisterListID = 0xFFFFFFFF;
 901     if ((PCI_REGISTER_BLOCK_HEADER *) MemS3RegListOr[PCI_LST_ESR_OR - PCI_LST_ESR_OR + i] != NULL) {
 902       DescriptPtr->PCIDevice[i].RegisterListID = PCI_LST_ESR_OR + i;
 903       Size += sizeof (PCI_DEVICE_DESCRIPTOR);
 904     }
 905     DescriptPtr->CPCIDevice[i].Type = (UINT8) (DEV_TYPE_CPCI_PRE_ESR + i);
 906     DescriptPtr->CPCIDevice[i].Node = NBPtr->Node;
 907     DescriptPtr->CPCIDevice[i].RegisterListID = 0xFFFFFFFF;
 908     if ((CPCI_REGISTER_BLOCK_HEADER *) MemS3RegListOr[CPCI_LST_ESR_OR - PCI_LST_ESR_OR + i] != NULL) {
 909       DescriptPtr->CPCIDevice[i].RegisterListID = CPCI_LST_ESR_OR + i;
 910       Size += sizeof (CONDITIONAL_PCI_DEVICE_DESCRIPTOR);
 911     }
 912     DescriptPtr->MSRDevice[i].Type = (UINT8) (DEV_TYPE_MSR_PRE_ESR + i);
 913     DescriptPtr->MSRDevice[i].RegisterListID = 0xFFFFFFFF;
 914     if ((MSR_REGISTER_BLOCK_HEADER *) MemS3RegListOr[MSR_LST_ESR_OR - PCI_LST_ESR_OR + i] != NULL) {
 915       DescriptPtr->MSRDevice[i].RegisterListID = MSR_LST_ESR_OR + i;
 916       Size += sizeof (MSR_DEVICE_DESCRIPTOR);
 917     }
 918     DescriptPtr->CMSRDevice[i].Type = (UINT8) (DEV_TYPE_CMSR_PRE_ESR + i);
 919     DescriptPtr->CMSRDevice[i].RegisterListID = 0xFFFFFFFF;
 920     if ((CMSR_REGISTER_BLOCK_HEADER *) MemS3RegListOr[CMSR_LST_ESR_OR - PCI_LST_ESR_OR + i] != NULL) {
 921       DescriptPtr->CMSRDevice[i].RegisterListID = CMSR_LST_ESR_OR + i;
 922       Size += sizeof (CONDITIONAL_MSR_DEVICE_DESCRIPTOR);
 923     }
 924   }
 925   return Size;
 926 }
 927
 928 /* -----------------------------------------------------------------------------*/
 929 /**
 930  *
 931  *
 932  *   This function return the register list according to the register ID.
 933  *
 934  *     @param[in]   RegisterLstID - value of the Register list ID.
 935  *     @param[out]  **RegisterHeader - pointer to the address of the register list.
 936  *     @return      none
 937  */
 938 AGESA_STATUS
 939 STATIC
 940 MemNS3GetDeviceRegLstOr (
 941   IN       UINT32 RegisterLstID,
 942      OUT   VOID **RegisterHeader
 943   )
 944 {
 945   if (RegisterLstID >= (sizeof (MemS3RegListOr) / sizeof (VOID *))) {
 946     ASSERT(FALSE); // RegisterListID exceeded size of Register list
 947     return AGESA_FATAL;
 948   }
 949   if (MemS3RegListOr[RegisterLstID] != NULL) {
 950     *RegisterHeader = MemS3RegListOr[RegisterLstID];
 951     return AGESA_SUCCESS;
 952   }
 953   ASSERT(FALSE); // Device register list error
 954   return AGESA_FATAL;
 955 }
 956
 957 /* -----------------------------------------------------------------------------*/
 958 /**
 959  *
 960  *
 961  *   This function that set PllLockTime to default state.
 962  *
 963  *     @param[in]   AccessWidth - Access width of the register.
 964  *     @param[in]   Address - address in PCI_ADDR format.
 965  *     @param[in, out]  *Value - Pointer to the value to be written.
 966  *     @param[in, out]  *ConfigPtr - Pointer to Config handle.
 967  *     @return         none
 968  */
 969 VOID
 970 STATIC
 971 MemNS3SetDfltPllLockTimeOr (
 972   IN       ACCESS_WIDTH AccessWidth,
 973   IN       PCI_ADDR Address,
 974   IN       VOID *Value,
 975   IN OUT   VOID *ConfigPtr
 976   )
 977 {
 978   UINT16 RegValue;
 979
 980   RegValue = 0x190;
 981   MemNS3SetBitFieldNb (AccessS3SaveWidth16, Address, &RegValue, ConfigPtr);
 982 }
 983
 984 /* -----------------------------------------------------------------------------*/
 985 /**
 986  *
 987  *
 988  *   This function sets bit 31 [DynModeChange] of F2x9C_xB
 989  *
 990  *     @param[in]   AccessWidth - Access width of the register.
 991  *     @param[in]   Address - address in PCI_ADDR format.
 992  *     @param[in, out]  *Value - Pointer to the value to be written.
 993  *     @param[in, out]  *ConfigPtr - Pointer to Config handle.
 994  *     @return         none
 995  */
 996 VOID
 997 MemNS3SetDynModeChangeOr (
 998   IN       ACCESS_WIDTH AccessWidth,
 999   IN       PCI_ADDR Address,
1000   IN OUT   VOID *Value,
1001   IN OUT   VOID *ConfigPtr
1002   )
1003 {
1004   UINT8 Dct;
1005   UINT32 RegValue;
1006   UINT32 Temp;
1007   UINT32 TempValue;
1008
1009   IDS_SKIP_HOOK (IDS_BEFORE_S3_SPECIAL, &Address, ConfigPtr) {
1010     Temp = Address.Address.Register;
1011     Dct = ((Temp & 0x400) == 0) ? 0 : 1;
1012
1013     // Switch Dct
1014     Address.Address.Function = FUNC_1;
1015     Address.Address.Register = 0x10C;
1016     TempValue = Dct;
1017     LibAmdPciWrite (AccessS3SaveWidth32, Address, &TempValue, ConfigPtr);
1018
1019     Address.Address.Function = FUNC_2;
1020     Address.Address.Register = Temp;
1021     RegValue = 0x80000000;
1022     MemNS3SetCSRNb (AccessS3SaveWidth32, Address, &RegValue, ConfigPtr);
1023   }
1024 }
1025
1026 /* -----------------------------------------------------------------------------*/
1027 /**
1028  *
1029  *
1030  *   This function saves the heap data of MR0 and chipsel enable map before S3
1031  *   entry
1032  *
1033  *     @param[in]   AccessWidth - Access width of the register.
1034  *     @param[in]   Address - address in PCI_ADDR format.
1035  *     @param[in, out]  *Value - Pointer to the value to be written.
1036  *     @param[in, out]  *ConfigPtr - Pointer to Config handle.
1037  *     @return         none
1038  */
1039 VOID
1040 MemNS3SaveMR0Or (
1041   IN       ACCESS_WIDTH AccessWidth,
1042   IN       PCI_ADDR Address,
1043   IN OUT   VOID *Value,
1044   IN OUT   VOID *ConfigPtr
1045   )
1046 {
1047   AGESA_STATUS Status;
1048   LOCATE_HEAP_PTR LocateHeapStructPtr;
1049   MR0_DATA_ARRAY_PTR pMR0Data;
1050   UINT32 Node;
1051   UINT32 Dct;
1052
1053   Node = Address.Address.Device - 0x18;
1054   Dct = Address.Address.Function;
1055
1056   // Get original MR0 from heap
1057   LocateHeapStructPtr.BufferHandle = AMD_MEM_S3_MR0_DATA_HANDLE;
1058   LocateHeapStructPtr.BufferPtr = NULL;
1059   Status = HeapLocateBuffer (&LocateHeapStructPtr, ConfigPtr);
1060   ASSERT (Status == AGESA_SUCCESS);
1061   pMR0Data = (MR0_DATA_ARRAY_PTR) (LocateHeapStructPtr.BufferPtr);
1062   ASSERT (pMR0Data != NULL);
1063
1064   IDS_HDT_CONSOLE (MEM_FLOW, "\tSave MR0 for S3 resume\n\t\tNode: %d, Dct: %d, ChipSelEnMap: %04X, MR0: %04X\n", Node, Dct, (*pMR0Data)[Node][Dct].ChipSelEnMap, (*pMR0Data)[Node][Dct].MR0Value);
1065   *(UINT32*) Value = (*pMR0Data)[Node][Dct].MR0Value;
1066   *(UINT32*) Value <<= 16;
1067   *(UINT32*) Value |= (*pMR0Data)[Node][Dct].ChipSelEnMap;
1068 }
1069
1070 /**
1071  *
1072  *
1073  *   This function send an MRS command to set MR0[PPD] after exit self-refresh
1074  *
1075  *     @param[in]   AccessWidth - Access width of the register.
1076  *     @param[in]   Address - address in PCI_ADDR format.
1077  *     @param[in, out]  *Value - Pointer to the value to be written.
1078  *     @param[in, out]  *ConfigPtr - Pointer to Config handle.
1079  *     @return         none
1080  */
1081 VOID
1082 MemNS3RestoreMR0SetPPDOr (
1083   IN       ACCESS_WIDTH AccessWidth,
1084   IN       PCI_ADDR Address,
1085   IN OUT   VOID *Value,
1086   IN OUT   VOID *ConfigPtr
1087   )
1088 {
1089   UINT32 Node;
1090   UINT32 Dct;
1091   UINT16 ChipSelEnMap;
1092   UINT16 MR0Value;
1093   UINT32 TempValue;
1094   UINT32 PowerDownMode;
1095   UINT32 PchgPDModeSel;
1096   UINT8 ChipSel;
1097
1098   Node = Address.Address.Device - 0x18;
1099   Dct = Address.Address.Function;
1100   ChipSelEnMap = (UINT16) ((*(UINT32*) Value) & 0xFFFF);
1101   MR0Value = (UINT16) (((*(UINT32*) Value) >> 16) & 0xFFFF);
1102
1103   Address.Address.Register = BFPowerDownMode;
1104   MemNS3GetBitFieldNb (AccessS3SaveWidth32, Address, &TempValue, ConfigPtr);
1105   PowerDownMode = TempValue;
1106
1107   Address.Address.Register = BFPchgPDModeSel;
1108   MemNS3GetBitFieldNb (AccessS3SaveWidth32, Address, &TempValue, ConfigPtr);
1109   PchgPDModeSel = TempValue;
1110
1111   // Check if Fast exit pre-charge powerdown mode is desired
1112   // D18F2x84[PowerDownMode] = 0
1113   // D18F2x94[PchgPDModeSel] = 0
1114   // MR0[PPD] = 1
1115   if (PowerDownMode == 0 && PchgPDModeSel == 0 && (MR0Value & 0x1000) == 0x1000) {
1116     for (ChipSel = 0; ChipSel < MAX_CS_PER_CHANNEL; ChipSel++) {
1117       if (((ChipSelEnMap >> ChipSel) & 1) != 0) {
1118         // if chip select present
1119         Address.Address.Register = BFMrsChipSel;
1120         MemNS3SetBitFieldNb (AccessS3SaveWidth32, Address, &ChipSel, ConfigPtr);
1121         // BA2=0,BA1=0,BA0=0
1122         TempValue = 0;
1123         Address.Address.Register = BFMrsBank;
1124         MemNS3SetBitFieldNb (AccessS3SaveWidth32, Address, &TempValue, ConfigPtr);
1125         Address.Address.Register = BFMrsAddress;
1126         MemNS3SetBitFieldNb (AccessS3SaveWidth16, Address, &MR0Value, ConfigPtr);
1127         // Bit swapping is not needed here because hardware bit swapping does not occur for commands
1128         // sent via D18F2x7C_dct[1:0][SendMrsCmd] when D18F2x7C_dct[1:0][EndDramInit] = 0
1129         TempValue = 1;
1130         Address.Address.Register = BFSendMrsCmd;
1131         MemNS3SetBitFieldNb (AccessS3SaveWidth32, Address, &TempValue, ConfigPtr);
1132         IDS_HDT_CONSOLE (MEM_FLOW, "\tIssue MRS Command after ESR\n\t\tNode: %d, Dct: %d, CS: %d, MR0: %08X\n", Node, Dct, ChipSel, MR0Value);
1133         Address.Address.Register = BFSendMrsCmd;
1134         MemNS3GetBitFieldNb (AccessS3SaveWidth32, Address, &TempValue, ConfigPtr);
1135         while (TempValue != 0) {
1136           MemNS3GetBitFieldNb (AccessS3SaveWidth32, Address, &TempValue, ConfigPtr);
1137         }
1138         WaitMicroseconds (500, ConfigPtr);
1139       }
1140     }
1141   }
1142 }
1143
1144 /* -----------------------------------------------------------------------------*/
1145 /**
1146  *
1147  *
1148  *   This function read the value of CSR register.
1149  *
1150  *     @param[in]   AccessWidth - Access width of the register
1151  *     @param[in]   Address - address of the CSR register in PCI_ADDR format.
1152  *     @param[in]  *Value - Pointer to the value be read.
1153  *     @param[in, out]  *ConfigPtr - Pointer to Config handle.
1154  *     @return         none
1155  */
1156 VOID
1157 STATIC
1158 MemNS3GetCSROr (
1159   IN       ACCESS_WIDTH AccessWidth,
1160   IN       PCI_ADDR Address,
1161   IN       VOID *Value,
1162   IN OUT   VOID *ConfigPtr
1163   )
1164 {
1165   UINT32 ExtendOffset;
1166   UINT32 ValueRead;
1167   UINT32 TempFunc;
1168   UINT32 TempValue;
1169
1170   ValueRead = 0;
1171   ExtendOffset = Address.Address.Register;
1172   TempFunc = Address.Address.Function;
1173
1174   // Switch Dct
1175   Address.Address.Function = FUNC_1;
1176   Address.Address.Register = 0x10C;
1177   TempValue = 0;
1178   if (ExtendOffset & 0x400) {
1179     TempValue = 1;
1180   }
1181   LibAmdPciWrite (AccessS3SaveWidth32, Address, &TempValue, ConfigPtr);
1182   Address.Address.Function = TempFunc;
1183
1184   Address.Address.Register = 0x98;
1185   ExtendOffset &= 0x3FF;
1186   LibAmdPciWrite (AccessS3SaveWidth32, Address, &ExtendOffset, ConfigPtr);
1187   while (((ValueRead >> 31) & 1) == 0) {
1188     LibAmdPciRead (AccessS3SaveWidth32, Address, &ValueRead, ConfigPtr);
1189   }
1190   Address.Address.Register = 0x9C;
1191   LibAmdPciRead (AccessWidth, Address, Value, ConfigPtr);
1192 }
1193
1194 /* -----------------------------------------------------------------------------*/
1195 /**
1196  *
1197  *
1198  *   This function write to a CSR register
1199  *
1200  *     @param[in]   AccessWidth - Access width of the register
1201  *     @param[in]   Address - address of the CSR register in PCI_ADDR format.
1202  *     @param[in, out]  *Value - Pointer to the value be read.
1203  *     @param[in, out]  *ConfigPtr - Pointer to Config handle.
1204  *     @return         none
1205  */
1206 VOID
1207 STATIC
1208 MemNS3SetCSROr (
1209   IN       ACCESS_WIDTH AccessWidth,
1210   IN       PCI_ADDR Address,
1211   IN OUT   VOID *Value,
1212   IN OUT   VOID *ConfigPtr
1213   )
1214 {
1215   UINT32 ExtendOffset;
1216   UINT32 ValueRead;
1217   UINT32 ValueWrite;
1218   UINT32 TempFunc;
1219   UINT32 TempValue;
1220
1221   ValueRead = 0;
1222   ExtendOffset = Address.Address.Register;
1223   TempFunc = Address.Address.Function;
1224   // Switch Dct
1225   Address.Address.Function = FUNC_1;
1226   Address.Address.Register = 0x10C;
1227   TempValue = 0;
1228   if (ExtendOffset & 0x400) {
1229     TempValue = 1;
1230   }
1231   LibAmdPciWrite (AccessS3SaveWidth32, Address, &TempValue, ConfigPtr);
1232
1233   Address.Address.Function = TempFunc;
1234   Address.Address.Register = 0x9C;
1235
1236   ExtendOffset &= 0x3FF;
1237   ExtendOffset |= 0x40000000;
1238   switch (AccessWidth) {
1239   case AccessS3SaveWidth8:
1240     ValueWrite = *(UINT8 *) Value;
1241     break;
1242   case AccessS3SaveWidth16:
1243     ValueWrite = *(UINT16 *) Value;
1244     break;
1245   case AccessS3SaveWidth32:
1246     ValueWrite = *(UINT32 *) Value;
1247     break;
1248   default:
1249     ASSERT (FALSE);
1250   }
1251   LibAmdPciWrite (AccessS3SaveWidth32, Address, &ValueWrite, ConfigPtr);
1252   Address.Address.Register = 0x98;
1253   LibAmdPciWrite (AccessS3SaveWidth32, Address, &ExtendOffset, ConfigPtr);
1254   while (((ValueRead >> 31) & 1) == 0) {
1255     LibAmdPciRead (AccessS3SaveWidth32, Address, &ValueRead, ConfigPtr);
1256   }
1257 }