src/northbridge/amd/amdk8/raminit.c

   1 /*      This should be done by Eric
   2         2004.11 yhlu add 4 rank DIMM support
   3         2004.12 yhlu add D0 support
   4         2005.02 yhlu add E0 memory hole support
   5 */
   6
   7 #include <cpu/x86/mem.h>
   8 #include <cpu/x86/cache.h>
   9 #include <cpu/x86/mtrr.h>
  10 #include "raminit.h"
  11 #include "amdk8.h"
  12
  13 #if (CONFIG_LB_MEM_TOPK & (CONFIG_LB_MEM_TOPK -1)) != 0
  14 # error "CONFIG_LB_MEM_TOPK must be a power of 2"
  15 #endif
  16
  17 #ifndef K8_4RANK_DIMM_SUPPORT
  18 #define K8_4RANK_DIMM_SUPPORT 0
  19 #endif
  20
  21 #if 1
  22 static void setup_resource_map(const unsigned int *register_values, int max)
  23 {
  24         int i;
  25 //      print_debug("setting up resource map....");
  26 #if 0
  27         print_debug("\r\n");
  28 #endif
  29         for(i = 0; i < max; i += 3) {
  30                 device_t dev;
  31                 unsigned where;
  32                 unsigned long reg;
  33 #if 0
  34         #if CONFIG_USE_INIT
  35                 prink_debug("%08x <- %08x\r\n", register_values[i], register_values[i+2]);
  36         #else
  37                 print_debug_hex32(register_values[i]);
  38                 print_debug(" <-");
  39                 print_debug_hex32(register_values[i+2]);
  40                 print_debug("\r\n");
  41         #endif
  42 #endif
  43                 dev = register_values[i] & ~0xff;
  44                 where = register_values[i] & 0xff;
  45                 reg = pci_read_config32(dev, where);
  46                 reg &= register_values[i+1];
  47                 reg |= register_values[i+2];
  48                 pci_write_config32(dev, where, reg);
  49 #if 0
  50                 reg = pci_read_config32(register_values[i]);
  51                 reg &= register_values[i+1];
  52                 reg |= register_values[i+2] & ~register_values[i+1];
  53                 pci_write_config32(register_values[i], reg);
  54 #endif
  55         }
  56 //      print_debug("done.\r\n");
  57 }
  58 #endif
  59
  60 static int controller_present(const struct mem_controller *ctrl)
  61 {
  62         return pci_read_config32(ctrl->f0, 0) == 0x11001022;
  63 }
  64
  65 static void sdram_set_registers(const struct mem_controller *ctrl)
  66 {
  67         static const unsigned int register_values[] = {
  68
  69         /* Careful set limit registers before base registers which contain the enables */
  70         /* DRAM Limit i Registers
  71          * F1:0x44 i = 0
  72          * F1:0x4C i = 1
  73          * F1:0x54 i = 2
  74          * F1:0x5C i = 3
  75          * F1:0x64 i = 4
  76          * F1:0x6C i = 5
  77          * F1:0x74 i = 6
  78          * F1:0x7C i = 7
  79          * [ 2: 0] Destination Node ID
  80          *         000 = Node 0
  81          *         001 = Node 1
  82          *         010 = Node 2
  83          *         011 = Node 3
  84          *         100 = Node 4
  85          *         101 = Node 5
  86          *         110 = Node 6
  87          *         111 = Node 7
  88          * [ 7: 3] Reserved
  89          * [10: 8] Interleave select
  90          *         specifies the values of A[14:12] to use with interleave enable.
  91          * [15:11] Reserved
  92          * [31:16] DRAM Limit Address i Bits 39-24
  93          *         This field defines the upper address bits of a 40 bit  address
  94          *         that define the end of the DRAM region.
  95          */
  96         PCI_ADDR(0, 0x18, 1, 0x44), 0x0000f8f8, 0x00000000,
  97         PCI_ADDR(0, 0x18, 1, 0x4C), 0x0000f8f8, 0x00000001,
  98         PCI_ADDR(0, 0x18, 1, 0x54), 0x0000f8f8, 0x00000002,
  99         PCI_ADDR(0, 0x18, 1, 0x5C), 0x0000f8f8, 0x00000003,
 100         PCI_ADDR(0, 0x18, 1, 0x64), 0x0000f8f8, 0x00000004,
 101         PCI_ADDR(0, 0x18, 1, 0x6C), 0x0000f8f8, 0x00000005,
 102         PCI_ADDR(0, 0x18, 1, 0x74), 0x0000f8f8, 0x00000006,
 103         PCI_ADDR(0, 0x18, 1, 0x7C), 0x0000f8f8, 0x00000007,
 104         /* DRAM Base i Registers
 105          * F1:0x40 i = 0
 106          * F1:0x48 i = 1
 107          * F1:0x50 i = 2
 108          * F1:0x58 i = 3
 109          * F1:0x60 i = 4
 110          * F1:0x68 i = 5
 111          * F1:0x70 i = 6
 112          * F1:0x78 i = 7
 113          * [ 0: 0] Read Enable
 114          *         0 = Reads Disabled
 115          *         1 = Reads Enabled
 116          * [ 1: 1] Write Enable
 117          *         0 = Writes Disabled
 118          *         1 = Writes Enabled
 119          * [ 7: 2] Reserved
 120          * [10: 8] Interleave Enable
 121          *         000 = No interleave
 122          *         001 = Interleave on A[12] (2 nodes)
 123          *         010 = reserved
 124          *         011 = Interleave on A[12] and A[14] (4 nodes)
 125          *         100 = reserved
 126          *         101 = reserved
 127          *         110 = reserved
 128          *         111 = Interleve on A[12] and A[13] and A[14] (8 nodes)
 129          * [15:11] Reserved
 130          * [13:16] DRAM Base Address i Bits 39-24
 131          *         This field defines the upper address bits of a 40-bit address
 132          *         that define the start of the DRAM region.
 133          */
 134         PCI_ADDR(0, 0x18, 1, 0x40), 0x0000f8fc, 0x00000000,
 135         PCI_ADDR(0, 0x18, 1, 0x48), 0x0000f8fc, 0x00000000,
 136         PCI_ADDR(0, 0x18, 1, 0x50), 0x0000f8fc, 0x00000000,
 137         PCI_ADDR(0, 0x18, 1, 0x58), 0x0000f8fc, 0x00000000,
 138         PCI_ADDR(0, 0x18, 1, 0x60), 0x0000f8fc, 0x00000000,
 139         PCI_ADDR(0, 0x18, 1, 0x68), 0x0000f8fc, 0x00000000,
 140         PCI_ADDR(0, 0x18, 1, 0x70), 0x0000f8fc, 0x00000000,
 141         PCI_ADDR(0, 0x18, 1, 0x78), 0x0000f8fc, 0x00000000,
 142
 143         /* DRAM CS Base Address i Registers
 144          * F2:0x40 i = 0
 145          * F2:0x44 i = 1
 146          * F2:0x48 i = 2
 147          * F2:0x4C i = 3
 148          * F2:0x50 i = 4
 149          * F2:0x54 i = 5
 150          * F2:0x58 i = 6
 151          * F2:0x5C i = 7
 152          * [ 0: 0] Chip-Select Bank Enable
 153          *         0 = Bank Disabled
 154          *         1 = Bank Enabled
 155          * [ 8: 1] Reserved
 156          * [15: 9] Base Address (19-13)
 157          *         An optimization used when all DIMM are the same size...
 158          * [20:16] Reserved
 159          * [31:21] Base Address (35-25)
 160          *         This field defines the top 11 addresses bit of a 40-bit
 161          *         address that define the memory address space.  These
 162          *         bits decode 32-MByte blocks of memory.
 163          */
 164         PCI_ADDR(0, 0x18, 2, 0x40), 0x001f01fe, 0x00000000,
 165         PCI_ADDR(0, 0x18, 2, 0x44), 0x001f01fe, 0x00000000,
 166         PCI_ADDR(0, 0x18, 2, 0x48), 0x001f01fe, 0x00000000,
 167         PCI_ADDR(0, 0x18, 2, 0x4C), 0x001f01fe, 0x00000000,
 168         PCI_ADDR(0, 0x18, 2, 0x50), 0x001f01fe, 0x00000000,
 169         PCI_ADDR(0, 0x18, 2, 0x54), 0x001f01fe, 0x00000000,
 170         PCI_ADDR(0, 0x18, 2, 0x58), 0x001f01fe, 0x00000000,
 171         PCI_ADDR(0, 0x18, 2, 0x5C), 0x001f01fe, 0x00000000,
 172         /* DRAM CS Mask Address i Registers
 173          * F2:0x60 i = 0
 174          * F2:0x64 i = 1
 175          * F2:0x68 i = 2
 176          * F2:0x6C i = 3
 177          * F2:0x70 i = 4
 178          * F2:0x74 i = 5
 179          * F2:0x78 i = 6
 180          * F2:0x7C i = 7
 181          * Select bits to exclude from comparison with the DRAM Base address register.
 182          * [ 8: 0] Reserved
 183          * [15: 9] Address Mask (19-13)
 184          *         Address to be excluded from the optimized case
 185          * [20:16] Reserved
 186          * [29:21] Address Mask (33-25)
 187          *         The bits with an address mask of 1 are excluded from address comparison
 188          * [31:30] Reserved
 189          *
 190          */
 191         PCI_ADDR(0, 0x18, 2, 0x60), 0xC01f01ff, 0x00000000,
 192         PCI_ADDR(0, 0x18, 2, 0x64), 0xC01f01ff, 0x00000000,
 193         PCI_ADDR(0, 0x18, 2, 0x68), 0xC01f01ff, 0x00000000,
 194         PCI_ADDR(0, 0x18, 2, 0x6C), 0xC01f01ff, 0x00000000,
 195         PCI_ADDR(0, 0x18, 2, 0x70), 0xC01f01ff, 0x00000000,
 196         PCI_ADDR(0, 0x18, 2, 0x74), 0xC01f01ff, 0x00000000,
 197         PCI_ADDR(0, 0x18, 2, 0x78), 0xC01f01ff, 0x00000000,
 198         PCI_ADDR(0, 0x18, 2, 0x7C), 0xC01f01ff, 0x00000000,
 199         /* DRAM Bank Address Mapping Register
 200          * F2:0x80
 201          * Specify the memory module size
 202          * [ 2: 0] CS1/0
 203          * [ 6: 4] CS3/2
 204          * [10: 8] CS5/4
 205          * [14:12] CS7/6
 206          *         000 = 32Mbyte  (Rows = 12 & Col =  8)
 207          *         001 = 64Mbyte  (Rows = 12 & Col =  9)
 208          *         010 = 128Mbyte (Rows = 13 & Col =  9)|(Rows = 12 & Col = 10)
 209          *         011 = 256Mbyte (Rows = 13 & Col = 10)|(Rows = 12 & Col = 11)
 210          *         100 = 512Mbyte (Rows = 13 & Col = 11)|(Rows = 14 & Col = 10)
 211          *         101 = 1Gbyte   (Rows = 14 & Col = 11)|(Rows = 13 & Col = 12)
 212          *         110 = 2Gbyte   (Rows = 14 & Col = 12)
 213          *         111 = reserved
 214          * [ 3: 3] Reserved
 215          * [ 7: 7] Reserved
 216          * [11:11] Reserved
 217          * [31:15]
 218          */
 219         PCI_ADDR(0, 0x18, 2, 0x80), 0xffff8888, 0x00000000,
 220         /* DRAM Timing Low Register
 221          * F2:0x88
 222          * [ 2: 0] Tcl (Cas# Latency, Cas# to read-data-valid)
 223          *         000 = reserved
 224          *         001 = CL 2
 225          *         010 = CL 3
 226          *         011 = reserved
 227          *         100 = reserved
 228          *         101 = CL 2.5
 229          *         110 = reserved
 230          *         111 = reserved
 231          * [ 3: 3] Reserved
 232          * [ 7: 4] Trc (Row Cycle Time, Ras#-active to Ras#-active/bank auto refresh)
 233          *         0000 =  7 bus clocks
 234          *         0001 =  8 bus clocks
 235          *         ...
 236          *         1110 = 21 bus clocks
 237          *         1111 = 22 bus clocks
 238          * [11: 8] Trfc (Row refresh Cycle time, Auto-refresh-active to RAS#-active or RAS#auto-refresh)
 239          *         0000 = 9 bus clocks
 240          *         0010 = 10 bus clocks
 241          *         ....
 242          *         1110 = 23 bus clocks
 243          *         1111 = 24 bus clocks
 244          * [14:12] Trcd (Ras#-active to Case#-read/write Delay)
 245          *         000 = reserved
 246          *         001 = reserved
 247          *         010 = 2 bus clocks
 248          *         011 = 3 bus clocks
 249          *         100 = 4 bus clocks
 250          *         101 = 5 bus clocks
 251          *         110 = 6 bus clocks
 252          *         111 = reserved
 253          * [15:15] Reserved
 254          * [18:16] Trrd (Ras# to Ras# Delay)
 255          *         000 = reserved
 256          *         001 = reserved
 257          *         010 = 2 bus clocks
 258          *         011 = 3 bus clocks
 259          *         100 = 4 bus clocks
 260          *         101 = reserved
 261          *         110 = reserved
 262          *         111 = reserved
 263          * [19:19] Reserved
 264          * [23:20] Tras (Minmum Ras# Active Time)
 265          *         0000 to 0100 = reserved
 266          *         0101 = 5 bus clocks
 267          *         ...
 268          *         1111 = 15 bus clocks
 269          * [26:24] Trp (Row Precharge Time)
 270          *         000 = reserved
 271          *         001 = reserved
 272          *         010 = 2 bus clocks
 273          *         011 = 3 bus clocks
 274          *         100 = 4 bus clocks
 275          *         101 = 5 bus clocks
 276          *         110 = 6 bus clocks
 277          *         111 = reserved
 278          * [27:27] Reserved
 279          * [28:28] Twr (Write Recovery Time)
 280          *         0 = 2 bus clocks
 281          *         1 = 3 bus clocks
 282          * [31:29] Reserved
 283          */
 284         PCI_ADDR(0, 0x18, 2, 0x88), 0xe8088008, 0x02522001 /* 0x03623125 */ ,
 285         /* DRAM Timing High Register
 286          * F2:0x8C
 287          * [ 0: 0] Twtr (Write to Read Delay)
 288          *         0 = 1 bus Clocks
 289          *         1 = 2 bus Clocks
 290          * [ 3: 1] Reserved
 291          * [ 6: 4] Trwt (Read to Write Delay)
 292          *         000 = 1 bus clocks
 293          *         001 = 2 bus clocks
 294          *         010 = 3 bus clocks
 295          *         011 = 4 bus clocks
 296          *         100 = 5 bus clocks
 297          *         101 = 6 bus clocks
 298          *         110 = reserved
 299          *         111 = reserved
 300          * [ 7: 7] Reserved
 301          * [12: 8] Tref (Refresh Rate)
 302          *         00000 = 100Mhz 4K rows
 303          *         00001 = 133Mhz 4K rows
 304          *         00010 = 166Mhz 4K rows
 305          *         00011 = 200Mhz 4K rows
 306          *         01000 = 100Mhz 8K/16K rows
 307          *         01001 = 133Mhz 8K/16K rows
 308          *         01010 = 166Mhz 8K/16K rows
 309          *         01011 = 200Mhz 8K/16K rows
 310          * [19:13] Reserved
 311          * [22:20] Twcl (Write CAS Latency)
 312          *         000 = 1 Mem clock after CAS# (Unbuffered Dimms)
 313          *         001 = 2 Mem clocks after CAS# (Registered Dimms)
 314          * [31:23] Reserved
 315          */
 316         PCI_ADDR(0, 0x18, 2, 0x8c), 0xff8fe08e, (0 << 20)|(0 << 8)|(0 << 4)|(0 << 0),
 317         /* DRAM Config Low Register
 318          * F2:0x90
 319          * [ 0: 0] DLL Disable
 320          *         0 = Enabled
 321          *         1 = Disabled
 322          * [ 1: 1] D_DRV
 323          *         0 = Normal Drive
 324          *         1 = Weak Drive
 325          * [ 2: 2] QFC_EN
 326          *         0 = Disabled
 327          *         1 = Enabled
 328          * [ 3: 3] Disable DQS Hystersis  (FIXME handle this one carefully)
 329          *         0 = Enable DQS input filter
 330          *         1 = Disable DQS input filtering
 331          * [ 7: 4] Reserved
 332          * [ 8: 8] DRAM_Init
 333          *         0 = Initialization done or not yet started.
 334          *         1 = Initiate DRAM intialization sequence
 335          * [ 9: 9] SO-Dimm Enable
 336          *         0 = Do nothing
 337          *         1 = SO-Dimms present
 338          * [10:10] DramEnable
 339          *         0 = DRAM not enabled
 340          *         1 = DRAM initialized and enabled
 341          * [11:11] Memory Clear Status
 342          *         0 = Memory Clear function has not completed
 343          *         1 = Memory Clear function has completed
 344          * [12:12] Exit Self-Refresh
 345          *         0 = Exit from self-refresh done or not yet started
 346          *         1 = DRAM exiting from self refresh
 347          * [13:13] Self-Refresh Status
 348          *         0 = Normal Operation
 349          *         1 = Self-refresh mode active
 350          * [15:14] Read/Write Queue Bypass Count
 351          *         00 = 2
 352          *         01 = 4
 353          *         10 = 8
 354          *         11 = 16
 355          * [16:16] 128-bit/64-Bit
 356          *         0 = 64bit Interface to DRAM
 357          *         1 = 128bit Interface to DRAM
 358          * [17:17] DIMM ECC Enable
 359          *         0 = Some DIMMs do not have ECC
 360          *         1 = ALL DIMMS have ECC bits
 361          * [18:18] UnBuffered DIMMs
 362          *         0 = Buffered DIMMS
 363          *         1 = Unbuffered DIMMS
 364          * [19:19] Enable 32-Byte Granularity
 365          *         0 = Optimize for 64byte bursts
 366          *         1 = Optimize for 32byte bursts
 367          * [20:20] DIMM 0 is x4
 368          * [21:21] DIMM 1 is x4
 369          * [22:22] DIMM 2 is x4
 370          * [23:23] DIMM 3 is x4
 371          *         0 = DIMM is not x4
 372          *         1 = x4 DIMM present
 373          * [24:24] Disable DRAM Receivers
 374          *         0 = Receivers enabled
 375          *         1 = Receivers disabled
 376          * [27:25] Bypass Max
 377          *         000 = Arbiters chois is always respected
 378          *         001 = Oldest entry in DCQ can be bypassed 1 time
 379          *         010 = Oldest entry in DCQ can be bypassed 2 times
 380          *         011 = Oldest entry in DCQ can be bypassed 3 times
 381          *         100 = Oldest entry in DCQ can be bypassed 4 times
 382          *         101 = Oldest entry in DCQ can be bypassed 5 times
 383          *         110 = Oldest entry in DCQ can be bypassed 6 times
 384          *         111 = Oldest entry in DCQ can be bypassed 7 times
 385          * [31:28] Reserved
 386          */
 387         PCI_ADDR(0, 0x18, 2, 0x90), 0xf0000000,
 388         (4 << 25)|(0 << 24)|
 389         (0 << 23)|(0 << 22)|(0 << 21)|(0 << 20)|
 390         (1 << 19)|(0 << 18)|(1 << 17)|(0 << 16)|
 391         (2 << 14)|(0 << 13)|(0 << 12)|
 392         (0 << 11)|(0 << 10)|(0 << 9)|(0 << 8)|
 393         (0 << 3) |(0 << 1) |(0 << 0),
 394         /* DRAM Config High Register
 395          * F2:0x94
 396          * [ 0: 3] Maximum Asynchronous Latency
 397          *         0000 = 0 ns
 398          *         ...
 399          *         1111 = 15 ns
 400          * [ 7: 4] Reserved
 401          * [11: 8] Read Preamble
 402          *         0000 = 2.0 ns
 403          *         0001 = 2.5 ns
 404          *         0010 = 3.0 ns
 405          *         0011 = 3.5 ns
 406          *         0100 = 4.0 ns
 407          *         0101 = 4.5 ns
 408          *         0110 = 5.0 ns
 409          *         0111 = 5.5 ns
 410          *         1000 = 6.0 ns
 411          *         1001 = 6.5 ns
 412          *         1010 = 7.0 ns
 413          *         1011 = 7.5 ns
 414          *         1100 = 8.0 ns
 415          *         1101 = 8.5 ns
 416          *         1110 = 9.0 ns
 417          *         1111 = 9.5 ns
 418          * [15:12] Reserved
 419          * [18:16] Idle Cycle Limit
 420          *         000 = 0 cycles
 421          *         001 = 4 cycles
 422          *         010 = 8 cycles
 423          *         011 = 16 cycles
 424          *         100 = 32 cycles
 425          *         101 = 64 cycles
 426          *         110 = 128 cycles
 427          *         111 = 256 cycles
 428          * [19:19] Dynamic Idle Cycle Center Enable
 429          *         0 = Use Idle Cycle Limit
 430          *         1 = Generate a dynamic Idle cycle limit
 431          * [22:20] DRAM MEMCLK Frequency
 432          *         000 = 100Mhz
 433          *         001 = reserved
 434          *         010 = 133Mhz
 435          *         011 = reserved
 436          *         100 = reserved
 437          *         101 = 166Mhz
 438          *         110 = reserved
 439          *         111 = reserved
 440          * [24:23] Reserved
 441          * [25:25] Memory Clock Ratio Valid (FIXME carefully enable memclk)
 442          *         0 = Disable MemClks
 443          *         1 = Enable MemClks
 444          * [26:26] Memory Clock 0 Enable
 445          *         0 = Disabled
 446          *         1 = Enabled
 447          * [27:27] Memory Clock 1 Enable
 448          *         0 = Disabled
 449          *         1 = Enabled
 450          * [28:28] Memory Clock 2 Enable
 451          *         0 = Disabled
 452          *         1 = Enabled
 453          * [29:29] Memory Clock 3 Enable
 454          *         0 = Disabled
 455          *         1 = Enabled
 456          * [31:30] Reserved
 457          */
 458         PCI_ADDR(0, 0x18, 2, 0x94), 0xc180f0f0,
 459         (0 << 29)|(0 << 28)|(0 << 27)|(0 << 26)|(0 << 25)|
 460         (0 << 20)|(0 << 19)|(DCH_IDLE_LIMIT_16 << 16)|(0 << 8)|(0 << 0),
 461         /* DRAM Delay Line Register
 462          * F2:0x98
 463          * Adjust the skew of the input DQS strobe relative to DATA
 464          * [15: 0] Reserved
 465          * [23:16] Delay Line Adjust
 466          *         Adjusts the DLL derived PDL delay by one or more delay stages
 467          *         in either the faster or slower direction.
 468          * [24:24} Adjust Slower
 469          *         0 = Do Nothing
 470          *         1 = Adj is used to increase the PDL delay
 471          * [25:25] Adjust Faster
 472          *         0 = Do Nothing
 473          *         1 = Adj is used to decrease the PDL delay
 474          * [31:26] Reserved
 475          */
 476         PCI_ADDR(0, 0x18, 2, 0x98), 0xfc00ffff, 0x00000000,
 477         /* DRAM Scrub Control Register
 478          * F3:0x58
 479          * [ 4: 0] DRAM Scrube Rate
 480          * [ 7: 5] reserved
 481          * [12: 8] L2 Scrub Rate
 482          * [15:13] reserved
 483          * [20:16] Dcache Scrub
 484          * [31:21] reserved
 485          *         Scrub Rates
 486          *         00000 = Do not scrub
 487          *         00001 =  40.00 ns
 488          *         00010 =  80.00 ns
 489          *         00011 = 160.00 ns
 490          *         00100 = 320.00 ns
 491          *         00101 = 640.00 ns
 492          *         00110 =   1.28 us
 493          *         00111 =   2.56 us
 494          *         01000 =   5.12 us
 495          *         01001 =  10.20 us
 496          *         01011 =  41.00 us
 497          *         01100 =  81.90 us
 498          *         01101 = 163.80 us
 499          *         01110 = 327.70 us
 500          *         01111 = 655.40 us
 501          *         10000 =   1.31 ms
 502          *         10001 =   2.62 ms
 503          *         10010 =   5.24 ms
 504          *         10011 =  10.49 ms
 505          *         10100 =  20.97 ms
 506          *         10101 =  42.00 ms
 507          *         10110 =  84.00 ms
 508          *         All Others = Reserved
 509          */
 510         PCI_ADDR(0, 0x18, 3, 0x58), 0xffe0e0e0, 0x00000000,
 511         /* DRAM Scrub Address Low Register
 512          * F3:0x5C
 513          * [ 0: 0] DRAM Scrubber Redirect Enable
 514          *         0 = Do nothing
 515          *         1 = Scrubber Corrects errors found in normal operation
 516          * [ 5: 1] Reserved
 517          * [31: 6] DRAM Scrub Address 31-6
 518          */
 519         PCI_ADDR(0, 0x18, 3, 0x5C), 0x0000003e, 0x00000000,
 520         /* DRAM Scrub Address High Register
 521          * F3:0x60
 522          * [ 7: 0] DRAM Scrubb Address 39-32
 523          * [31: 8] Reserved
 524          */
 525         PCI_ADDR(0, 0x18, 3, 0x60), 0xffffff00, 0x00000000,
 526         };
 527         int i;
 528         int max;
 529
 530 #if 1
 531         if (!controller_present(ctrl)) {
 532 //                print_debug("No memory controller present\r\n");
 533                 return;
 534         }
 535 #endif
 536         print_spew("setting up CPU");
 537         print_spew_hex8(ctrl->node_id);
 538         print_spew(" northbridge registers\r\n");
 539         max = sizeof(register_values)/sizeof(register_values[0]);
 540         for(i = 0; i < max; i += 3) {
 541                 device_t dev;
 542                 unsigned where;
 543                 unsigned long reg;
 544 #if 0
 545         #if CONFIG_USE_INIT
 546                 prink_debug("%08x <- %08x\r\n", register_values[i], register_values[i+2]);
 547         #else
 548                 print_spew_hex32(register_values[i]);
 549                 print_spew(" <-");
 550                 print_spew_hex32(register_values[i+2]);
 551                 print_spew("\r\n");
 552         #endif
 553 #endif
 554                 dev = (register_values[i] & ~0xff) - PCI_DEV(0, 0x18, 0) + ctrl->f0;
 555                 where = register_values[i] & 0xff;
 556                 reg = pci_read_config32(dev, where);
 557                 reg &= register_values[i+1];
 558                 reg |= register_values[i+2];
 559                 pci_write_config32(dev, where, reg);
 560 #if 0
 561
 562                 reg = pci_read_config32(register_values[i]);
 563                 reg &= register_values[i+1];
 564                 reg |= register_values[i+2];
 565                 pci_write_config32(register_values[i], reg);
 566 #endif
 567         }
 568         print_spew("done.\r\n");
 569 }
 570
 571
 572 static void hw_enable_ecc(const struct mem_controller *ctrl)
 573 {
 574         uint32_t dcl, nbcap;
 575         nbcap = pci_read_config32(ctrl->f3, NORTHBRIDGE_CAP);
 576         dcl = pci_read_config32(ctrl->f2, DRAM_CONFIG_LOW);
 577         dcl &= ~DCL_DimmEccEn;
 578         if (nbcap & NBCAP_ECC) {
 579                 dcl |= DCL_DimmEccEn;
 580         }
 581         if (read_option(CMOS_VSTART_ECC_memory, CMOS_VLEN_ECC_memory, 1) == 0) {
 582                 dcl &= ~DCL_DimmEccEn;
 583         }
 584         pci_write_config32(ctrl->f2, DRAM_CONFIG_LOW, dcl);
 585
 586 }
 587
 588 static int is_dual_channel(const struct mem_controller *ctrl)
 589 {
 590         uint32_t dcl;
 591         dcl = pci_read_config32(ctrl->f2, DRAM_CONFIG_LOW);
 592         return dcl & DCL_128BitEn;
 593 }
 594
 595 static int is_opteron(const struct mem_controller *ctrl)
 596 {
 597         /* Test to see if I am an Opteron.
 598          * FIXME Testing dual channel capability is correct for now
 599          * but a beter test is probably required.
 600          */
 601 #warning "FIXME implement a better test for opterons"
 602         uint32_t nbcap;
 603         nbcap = pci_read_config32(ctrl->f3, NORTHBRIDGE_CAP);
 604         return !!(nbcap & NBCAP_128Bit);
 605 }
 606
 607 static int is_registered(const struct mem_controller *ctrl)
 608 {
 609         /* Test to see if we are dealing with registered SDRAM.
 610          * If we are not registered we are unbuffered.
 611          * This function must be called after spd_handle_unbuffered_dimms.
 612          */
 613         uint32_t dcl;
 614         dcl = pci_read_config32(ctrl->f2, DRAM_CONFIG_LOW);
 615         return !(dcl & DCL_UnBufDimm);
 616 }
 617
 618 struct dimm_size {
 619         unsigned long side1;
 620         unsigned long side2;
 621         unsigned long rows;
 622         unsigned long col;
 623 #if K8_4RANK_DIMM_SUPPORT == 1
 624         unsigned long rank;
 625 #endif
 626 };
 627
 628 static struct dimm_size spd_get_dimm_size(unsigned device)
 629 {
 630         /* Calculate the log base 2 size of a DIMM in bits */
 631         struct dimm_size sz;
 632         int value, low;
 633         sz.side1 = 0;
 634         sz.side2 = 0;
 635         sz.rows = 0;
 636         sz.col = 0;
 637 #if K8_4RANK_DIMM_SUPPORT == 1
 638         sz.rank = 0;
 639 #endif
 640
 641         /* Note it might be easier to use byte 31 here, it has the DIMM size as
 642          * a multiple of 4MB.  The way we do it now we can size both
 643          * sides of an assymetric dimm.
 644          */
 645         value = spd_read_byte(device, 3);       /* rows */
 646         if (value < 0) goto hw_err;
 647         if ((value & 0xf) == 0) goto val_err;
 648         sz.side1 += value & 0xf;
 649         sz.rows = value & 0xf;
 650
 651         value = spd_read_byte(device, 4);       /* columns */
 652         if (value < 0) goto hw_err;
 653         if ((value & 0xf) == 0) goto val_err;
 654         sz.side1 += value & 0xf;
 655         sz.col = value & 0xf;
 656
 657         value = spd_read_byte(device, 17);      /* banks */
 658         if (value < 0) goto hw_err;
 659         if ((value & 0xff) == 0) goto val_err;
 660         sz.side1 += log2(value & 0xff);
 661
 662         /* Get the module data width and convert it to a power of two */
 663         value = spd_read_byte(device, 7);       /* (high byte) */
 664         if (value < 0) goto hw_err;
 665         value &= 0xff;
 666         value <<= 8;
 667
 668         low = spd_read_byte(device, 6); /* (low byte) */
 669         if (low < 0) goto hw_err;
 670         value = value | (low & 0xff);
 671         if ((value != 72) && (value != 64)) goto val_err;
 672         sz.side1 += log2(value);
 673
 674         /* side 2 */
 675         value = spd_read_byte(device, 5);       /* number of physical banks */
 676         if (value < 0) goto hw_err;
 677         if (value == 1) goto out;
 678         if ((value != 2) && (value != 4 )) {
 679                 goto val_err;
 680         }
 681 #if K8_4RANK_DIMM_SUPPORT == 1
 682         sz.rank = value;
 683 #endif
 684
 685         /* Start with the symmetrical case */
 686         sz.side2 = sz.side1;
 687
 688         value = spd_read_byte(device, 3);       /* rows */
 689         if (value < 0) goto hw_err;
 690         if ((value & 0xf0) == 0) goto out;      /* If symmetrical we are done */
 691         sz.side2 -= (value & 0x0f);             /* Subtract out rows on side 1 */
 692         sz.side2 += ((value >> 4) & 0x0f);      /* Add in rows on side 2 */
 693
 694         value = spd_read_byte(device, 4);       /* columns */
 695         if (value < 0) goto hw_err;
 696         if ((value & 0xff) == 0) goto val_err;
 697         sz.side2 -= (value & 0x0f);             /* Subtract out columns on side 1 */
 698         sz.side2 += ((value >> 4) & 0x0f);      /* Add in columsn on side 2 */
 699
 700         goto out;
 701
 702  val_err:
 703         die("Bad SPD value\r\n");
 704         /* If an hw_error occurs report that I have no memory */
 705 hw_err:
 706         sz.side1 = 0;
 707         sz.side2 = 0;
 708         sz.rows = 0;
 709         sz.col = 0;
 710 #if K8_4RANK_DIMM_SUPPORT == 1
 711         sz.rank = 0;
 712 #endif
 713  out:
 714         return sz;
 715 }
 716
 717
 718 static void set_dimm_size(const struct mem_controller *ctrl, struct dimm_size sz, unsigned index)
 719 {
 720         uint32_t base0, base1;
 721         uint32_t dch;
 722
 723         if (sz.side1 != sz.side2) {
 724                 sz.side2 = 0;
 725         }
 726
 727         /* For each base register.
 728          * Place the dimm size in 32 MB quantities in the bits 31 - 21.
 729          * The initialize dimm size is in bits.
 730          * Set the base enable bit0.
 731          */
 732
 733         base0 = base1 = 0;
 734
 735         /* Make certain side1 of the dimm is at least 32MB */
 736         if (sz.side1 >= (25 +3)) {
 737                 base0 = (1 << ((sz.side1 - (25 + 3)) + 21)) | 1;
 738         }
 739
 740         /* Make certain side2 of the dimm is at least 32MB */
 741         if (sz.side2 >= (25 + 3)) {
 742                 base1 = (1 << ((sz.side2 - (25 + 3)) + 21)) | 1;
 743         }
 744
 745         /* Double the size if we are using dual channel memory */
 746         if (is_dual_channel(ctrl)) {
 747                 base0 = (base0 << 1) | (base0 & 1);
 748                 base1 = (base1 << 1) | (base1 & 1);
 749         }
 750
 751         /* Clear the reserved bits */
 752         base0 &= ~0x001ffffe;
 753         base1 &= ~0x001ffffe;
 754
 755         /* Set the appropriate DIMM base address register */
 756         pci_write_config32(ctrl->f2, DRAM_CSBASE + (((index << 1)+0)<<2), base0);
 757         pci_write_config32(ctrl->f2, DRAM_CSBASE + (((index << 1)+1)<<2), base1);
 758 #if K8_4RANK_DIMM_SUPPORT == 1
 759         if(sz.rank == 4) {
 760                 pci_write_config32(ctrl->f2, DRAM_CSBASE + (((index << 1)+4)<<2), base0);
 761                 pci_write_config32(ctrl->f2, DRAM_CSBASE + (((index << 1)+5)<<2), base1);
 762         }
 763 #endif
 764
 765         /* Enable the memory clocks for this DIMM */
 766         if (base0) {
 767                 dch = pci_read_config32(ctrl->f2, DRAM_CONFIG_HIGH);
 768                 dch |= DCH_MEMCLK_EN0 << index;
 769 #if K8_4RANK_DIMM_SUPPORT == 1
 770                 if(sz.rank == 4) {
 771                         dch |= DCH_MEMCLK_EN0 << (index + 2);
 772                 }
 773 #endif
 774                 pci_write_config32(ctrl->f2, DRAM_CONFIG_HIGH, dch);
 775         }
 776 }
 777
 778 static void set_dimm_map(const struct mem_controller *ctrl, struct dimm_size sz, unsigned index)
 779 {
 780         static const unsigned cs_map_aa[] = {
 781                 /* (row=12, col=8)(14, 12) ---> (0, 0) (2, 4) */
 782                 0, 1, 3, 6, 0,
 783                 0, 2, 4, 7, 9,
 784                 0, 0, 5, 8,10,
 785         };
 786
 787         uint32_t map;
 788         uint32_t dch;
 789
 790         map = pci_read_config32(ctrl->f2, DRAM_BANK_ADDR_MAP);
 791         map &= ~(0xf << (index * 4));
 792 #if K8_4RANK_DIMM_SUPPORT == 1
 793         if(sz.rank == 4) {
 794                 map &= ~(0xf << ( (index + 2) * 4));
 795         }
 796 #endif
 797
 798
 799         /* Make certain side1 of the dimm is at least 32MB */
 800         if (sz.side1 >= (25 +3)) {
 801                 if(is_cpu_pre_d0()) {
 802                         map |= (sz.side1 - (25 + 3)) << (index *4);
 803 #if K8_4RANK_DIMM_SUPPORT == 1
 804                         if(sz.rank == 4) {
 805                               map |= (sz.side1 - (25 + 3)) << ( (index + 2) * 4);
 806                         }
 807 #endif
 808                 }
 809                 else {
 810                         map |= cs_map_aa[(sz.rows - 12) * 5 + (sz.col - 8) ] << (index*4);
 811 #if K8_4RANK_DIMM_SUPPORT == 1
 812                         if(sz.rank == 4) {
 813                                map |=  cs_map_aa[(sz.rows - 12) * 5 + (sz.col - 8) ] << ( (index + 2) * 4);
 814                         }
 815 #endif
 816                 }
 817         }
 818
 819         pci_write_config32(ctrl->f2, DRAM_BANK_ADDR_MAP, map);
 820
 821 }
 822
 823 static long spd_set_ram_size(const struct mem_controller *ctrl, long dimm_mask)
 824 {
 825         int i;
 826
 827         for(i = 0; i < DIMM_SOCKETS; i++) {
 828                 struct dimm_size sz;
 829                 if (!(dimm_mask & (1 << i))) {
 830                         continue;
 831                 }
 832                 sz = spd_get_dimm_size(ctrl->channel0[i]);
 833                 if (sz.side1 == 0) {
 834                         return -1; /* Report SPD error */
 835                 }
 836                 set_dimm_size(ctrl, sz, i);
 837                 set_dimm_map (ctrl, sz, i);
 838         }
 839         return dimm_mask;
 840 }
 841
 842 static void route_dram_accesses(const struct mem_controller *ctrl,
 843         unsigned long base_k, unsigned long limit_k)
 844 {
 845         /* Route the addresses to the controller node */
 846         unsigned node_id;
 847         unsigned limit;
 848         unsigned base;
 849         unsigned index;
 850         unsigned limit_reg, base_reg;
 851         device_t device;
 852
 853         node_id = ctrl->node_id;
 854         index = (node_id << 3);
 855         limit = (limit_k << 2);
 856         limit &= 0xffff0000;
 857         limit -= 0x00010000;
 858         limit |= ( 0 << 8) | (node_id << 0);
 859         base = (base_k << 2);
 860         base &= 0xffff0000;
 861         base |= (0 << 8) | (1<<1) | (1<<0);
 862
 863         limit_reg = 0x44 + index;
 864         base_reg = 0x40 + index;
 865         for(device = PCI_DEV(0, 0x18, 1); device <= PCI_DEV(0, 0x1f, 1); device += PCI_DEV(0, 1, 0)) {
 866                 pci_write_config32(device, limit_reg, limit);
 867                 pci_write_config32(device, base_reg, base);
 868         }
 869 }
 870
 871 static void set_top_mem(unsigned tom_k, unsigned hole_startk)
 872 {
 873         /* Error if I don't have memory */
 874         if (!tom_k) {
 875                 die("No memory?");
 876         }
 877
 878         /* Report the amount of memory. */
 879         print_spew("RAM: 0x");
 880         print_spew_hex32(tom_k);
 881         print_spew(" KB\r\n");
 882
 883         /* Now set top of memory */
 884         msr_t msr;
 885         if(tom_k>(4*1024*1024)) {
 886                 msr.lo = (tom_k & 0x003fffff) << 10;
 887                 msr.hi = (tom_k & 0xffc00000) >> 22;
 888                 wrmsr(TOP_MEM2, msr);
 889         }
 890
 891         /* Leave a 64M hole between TOP_MEM and TOP_MEM2
 892          * so I can see my rom chip and other I/O devices.
 893          */
 894         if (tom_k >= 0x003f0000) {
 895 #if K8_HW_MEM_HOLE_SIZEK != 0
 896                 if(hole_startk != 0) {
 897                         tom_k = hole_startk;
 898                 } else
 899 #endif
 900                 tom_k = 0x3f0000;
 901         }
 902         msr.lo = (tom_k & 0x003fffff) << 10;
 903         msr.hi = (tom_k & 0xffc00000) >> 22;
 904         wrmsr(TOP_MEM, msr);
 905 }
 906
 907 static unsigned long interleave_chip_selects(const struct mem_controller *ctrl)
 908 {
 909         /* 35 - 25 */
 910         static const uint8_t csbase_low_shift[] = {
 911         /* 32MB */      (13 - 4),
 912         /* 64MB */      (14 - 4),
 913         /* 128MB */     (14 - 4),
 914         /* 256MB */     (15 - 4),
 915         /* 512MB */     (15 - 4),
 916         /* 1GB */       (16 - 4),
 917         /* 2GB */       (16 - 4),
 918         };
 919
 920         static const uint8_t csbase_low_d0_shift[] = {
 921         /* 32MB */      (13 - 4),
 922         /* 64MB */      (14 - 4),
 923         /* 128MB */     (14 - 4),
 924         /* 128MB */     (15 - 4),
 925         /* 256MB */     (15 - 4),
 926         /* 512MB */     (15 - 4),
 927         /* 256MB */     (16 - 4),
 928         /* 512MB */     (16 - 4),
 929         /* 1GB */       (16 - 4),
 930         /* 1GB */       (17 - 4),
 931         /* 2GB */       (17 - 4),
 932         };
 933
 934         /* cs_base_high is not changed */
 935
 936         uint32_t csbase_inc;
 937         int chip_selects, index;
 938         int bits;
 939         unsigned common_size;
 940         unsigned common_cs_mode;
 941         uint32_t csbase, csmask;
 942
 943         /* See if all of the memory chip selects are the same size
 944          * and if so count them.
 945          */
 946         chip_selects = 0;
 947         common_size = 0;
 948         common_cs_mode = 0;
 949         for(index = 0; index < 8; index++) {
 950                 unsigned size;
 951                 unsigned cs_mode;
 952                 uint32_t value;
 953
 954                 value = pci_read_config32(ctrl->f2, DRAM_CSBASE + (index << 2));
 955
 956                 /* Is it enabled? */
 957                 if (!(value & 1)) {
 958                         continue;
 959                 }
 960                 chip_selects++;
 961                 size = value >> 21;
 962                 if (common_size == 0) {
 963                         common_size = size;
 964                 }
 965                 /* The size differed fail */
 966                 if (common_size != size) {
 967                         return 0;
 968                 }
 969
 970                 value = pci_read_config32(ctrl->f2, DRAM_BANK_ADDR_MAP);
 971                 cs_mode =( value >> ((index>>1)*4)) & 0xf;
 972                 if(cs_mode == 0 ) continue;
 973                 if(common_cs_mode == 0) {
 974                         common_cs_mode = cs_mode;
 975                 }
 976                 /* The size differed fail */
 977                 if(common_cs_mode != cs_mode) {
 978                         return 0;
 979                 }
 980         }
 981
 982         /* Chip selects can only be interleaved when there is
 983          * more than one and their is a power of two of them.
 984          */
 985         bits = log2(chip_selects);
 986         if (((1 << bits) != chip_selects) || (bits < 1) || (bits > 3)) {
 987                 return 0;
 988         }
 989
 990         /* Find the bits of csbase that we need to interleave on */
 991         if(is_cpu_pre_d0()){
 992                 csbase_inc = 1 << csbase_low_shift[common_cs_mode];
 993                 if(is_dual_channel(ctrl)) {
 994                 /* Also we run out of address mask bits if we try and interleave 8 4GB dimms */
 995                         if ((bits == 3) && (common_size == (1 << (32 - 3)))) {
 996 //                              print_debug("8 4GB chip selects cannot be interleaved\r\n");
 997                                 return 0;
 998                         }
 999                         csbase_inc <<=1;
1000                 }
1001         }
1002         else {
1003                 csbase_inc = 1 << csbase_low_d0_shift[common_cs_mode];
1004                 if(is_dual_channel(ctrl)) {
1005                         if( (bits==3) && (common_cs_mode > 8)) {
1006 //                              print_debug("8 cs_mode>8 chip selects cannot be interleaved\r\n");
1007                                 return 0;
1008                         }
1009                         csbase_inc <<=1;
1010                 }
1011         }
1012
1013         /* Compute the initial values for csbase and csbask.
1014          * In csbase just set the enable bit and the base to zero.
1015          * In csmask set the mask bits for the size and page level interleave.
1016          */
1017         csbase = 0 | 1;
1018         csmask = (((common_size  << bits) - 1) << 21);
1019         csmask |= 0xfe00 & ~((csbase_inc << bits) - csbase_inc);
1020         for(index = 0; index < 8; index++) {
1021                 uint32_t value;
1022
1023                 value = pci_read_config32(ctrl->f2, DRAM_CSBASE + (index << 2));
1024                 /* Is it enabled? */
1025                 if (!(value & 1)) {
1026                         continue;
1027                 }
1028                 pci_write_config32(ctrl->f2, DRAM_CSBASE + (index << 2), csbase);
1029                 pci_write_config32(ctrl->f2, DRAM_CSMASK + (index << 2), csmask);
1030                 csbase += csbase_inc;
1031         }
1032
1033         print_spew("Interleaved\r\n");
1034
1035         /* Return the memory size in K */
1036         return common_size << (15 + bits);
1037 }
1038
1039 static unsigned long order_chip_selects(const struct mem_controller *ctrl)
1040 {
1041         unsigned long tom;
1042
1043         /* Remember which registers we have used in the high 8 bits of tom */
1044         tom = 0;
1045         for(;;) {
1046                 /* Find the largest remaining canidate */
1047                 unsigned index, canidate;
1048                 uint32_t csbase, csmask;
1049                 unsigned size;
1050                 csbase = 0;
1051                 canidate = 0;
1052                 for(index = 0; index < 8; index++) {
1053                         uint32_t value;
1054                         value = pci_read_config32(ctrl->f2, DRAM_CSBASE + (index << 2));
1055
1056                         /* Is it enabled? */
1057                         if (!(value & 1)) {
1058                                 continue;
1059                         }
1060
1061                         /* Is it greater? */
1062                         if (value <= csbase) {
1063                                 continue;
1064                         }
1065
1066                         /* Has it already been selected */
1067                         if (tom & (1 << (index + 24))) {
1068                                 continue;
1069                         }
1070                         /* I have a new canidate */
1071                         csbase = value;
1072                         canidate = index;
1073                 }
1074                 /* See if I have found a new canidate */
1075                 if (csbase == 0) {
1076                         break;
1077                 }
1078
1079                 /* Remember the dimm size */
1080                 size = csbase >> 21;
1081
1082                 /* Remember I have used this register */
1083                 tom |= (1 << (canidate + 24));
1084
1085                 /* Recompute the cs base register value */
1086                 csbase = (tom << 21) | 1;
1087
1088                 /* Increment the top of memory */
1089                 tom += size;
1090
1091                 /* Compute the memory mask */
1092                 csmask = ((size -1) << 21);
1093                 csmask |= 0xfe00;               /* For now don't optimize */
1094
1095                 /* Write the new base register */
1096                 pci_write_config32(ctrl->f2, DRAM_CSBASE + (canidate << 2), csbase);
1097                 /* Write the new mask register */
1098                 pci_write_config32(ctrl->f2, DRAM_CSMASK + (canidate << 2), csmask);
1099
1100         }
1101         /* Return the memory size in K */
1102         return (tom & ~0xff000000) << 15;
1103 }
1104
1105 unsigned long memory_end_k(const struct mem_controller *ctrl, int max_node_id)
1106 {
1107         unsigned node_id;
1108         unsigned end_k;
1109         /* Find the last memory address used */
1110         end_k = 0;
1111         for(node_id = 0; node_id < max_node_id; node_id++) {
1112                 uint32_t limit, base;
1113                 unsigned index;
1114                 index = node_id << 3;
1115                 base = pci_read_config32(ctrl->f1, 0x40 + index);
1116                 /* Only look at the limit if the base is enabled */
1117                 if ((base & 3) == 3) {
1118                         limit = pci_read_config32(ctrl->f1, 0x44 + index);
1119                         end_k = ((limit + 0x00010000) & 0xffff0000) >> 2;
1120                 }
1121         }
1122         return end_k;
1123 }
1124
1125 static void order_dimms(const struct mem_controller *ctrl)
1126 {
1127         unsigned long tom_k, base_k;
1128
1129         if (read_option(CMOS_VSTART_interleave_chip_selects, CMOS_VLEN_interleave_chip_selects, 1) != 0) {
1130                 tom_k = interleave_chip_selects(ctrl);
1131         } else {
1132                 print_debug("Interleaving disabled\r\n");
1133                 tom_k = 0;
1134         }
1135         if (!tom_k) {
1136                 tom_k = order_chip_selects(ctrl);
1137         }
1138         /* Compute the memory base address */
1139         base_k = memory_end_k(ctrl, ctrl->node_id);
1140         tom_k += base_k;
1141         route_dram_accesses(ctrl, base_k, tom_k);
1142         set_top_mem(tom_k, 0);
1143 }
1144
1145 static long disable_dimm(const struct mem_controller *ctrl, unsigned index, long dimm_mask)
1146 {
1147         print_debug("disabling dimm");
1148         print_debug_hex8(index);
1149         print_debug("\r\n");
1150         pci_write_config32(ctrl->f2, DRAM_CSBASE + (((index << 1)+0)<<2), 0);
1151         pci_write_config32(ctrl->f2, DRAM_CSBASE + (((index << 1)+1)<<2), 0);
1152         dimm_mask &= ~(1 << index);
1153         return dimm_mask;
1154 }
1155
1156 static long spd_handle_unbuffered_dimms(const struct mem_controller *ctrl, long dimm_mask)
1157 {
1158         int i;
1159         int registered;
1160         int unbuffered;
1161         uint32_t dcl;
1162         unbuffered = 0;
1163         registered = 0;
1164         for(i = 0; (i < DIMM_SOCKETS); i++) {
1165                 int value;
1166                 if (!(dimm_mask & (1 << i))) {
1167                         continue;
1168                 }
1169                 value = spd_read_byte(ctrl->channel0[i], 21);
1170                 if (value < 0) {
1171                         return -1;
1172                 }
1173                 /* Registered dimm ? */
1174                 if (value & (1 << 1)) {
1175                         registered = 1;
1176                 }
1177                 /* Otherwise it must be an unbuffered dimm */
1178                 else {
1179                         unbuffered = 1;
1180                 }
1181         }
1182         if (unbuffered && registered) {
1183                 die("Mixed buffered and registered dimms not supported");
1184         }
1185 #if 1
1186         //By yhlu for debug Athlon64 939 can do dual channel, but it use unbuffer DIMM
1187         if (unbuffered && is_opteron(ctrl)) {
1188                 die("Unbuffered Dimms not supported on Opteron");
1189         }
1190 #endif
1191
1192         dcl = pci_read_config32(ctrl->f2, DRAM_CONFIG_LOW);
1193         dcl &= ~DCL_UnBufDimm;
1194         if (unbuffered) {
1195                 dcl |= DCL_UnBufDimm;
1196         }
1197         pci_write_config32(ctrl->f2, DRAM_CONFIG_LOW, dcl);
1198 #if 0
1199         if (is_registered(ctrl)) {
1200                 print_debug("Registered\r\n");
1201         } else {
1202                 print_debug("Unbuffered\r\n");
1203         }
1204 #endif
1205         return dimm_mask;
1206 }
1207
1208 static unsigned int spd_detect_dimms(const struct mem_controller *ctrl)
1209 {
1210         unsigned dimm_mask;
1211         int i;
1212         dimm_mask = 0;
1213         for(i = 0; i < DIMM_SOCKETS; i++) {
1214                 int byte;
1215                 unsigned device;
1216                 device = ctrl->channel0[i];
1217                 if (device) {
1218                         byte = spd_read_byte(ctrl->channel0[i], 2);  /* Type */
1219                         if (byte == 7) {
1220                                 dimm_mask |= (1 << i);
1221                         }
1222                 }
1223                 device = ctrl->channel1[i];
1224                 if (device) {
1225                         byte = spd_read_byte(ctrl->channel1[i], 2);
1226                         if (byte == 7) {
1227                                 dimm_mask |= (1 << (i + DIMM_SOCKETS));
1228                         }
1229                 }
1230         }
1231         return dimm_mask;
1232 }
1233
1234 static long spd_enable_2channels(const struct mem_controller *ctrl, long dimm_mask)
1235 {
1236         int i;
1237         uint32_t nbcap;
1238         /* SPD addresses to verify are identical */
1239         static const uint8_t addresses[] = {
1240                 2,      /* Type should be DDR SDRAM */
1241                 3,      /* *Row addresses */
1242                 4,      /* *Column addresses */
1243                 5,      /* *Physical Banks */
1244                 6,      /* *Module Data Width low */
1245                 7,      /* *Module Data Width high */
1246                 9,      /* *Cycle time at highest CAS Latency CL=X */
1247                 11,     /* *SDRAM Type */
1248                 13,     /* *SDRAM Width */
1249                 17,     /* *Logical Banks */
1250                 18,     /* *Supported CAS Latencies */
1251                 21,     /* *SDRAM Module Attributes */
1252                 23,     /* *Cycle time at CAS Latnecy (CLX - 0.5) */
1253                 26,     /* *Cycle time at CAS Latnecy (CLX - 1.0) */
1254                 27,     /* *tRP Row precharge time */
1255                 28,     /* *Minimum Row Active to Row Active Delay (tRRD) */
1256                 29,     /* *tRCD RAS to CAS */
1257                 30,     /* *tRAS Activate to Precharge */
1258                 41,     /* *Minimum Active to Active/Auto Refresh Time(Trc) */
1259                 42,     /* *Minimum Auto Refresh Command Time(Trfc) */
1260         };
1261         /* If the dimms are not in pairs do not do dual channels */
1262         if ((dimm_mask & ((1 << DIMM_SOCKETS) - 1)) !=
1263                 ((dimm_mask >> DIMM_SOCKETS) & ((1 << DIMM_SOCKETS) - 1))) {
1264                 goto single_channel;
1265         }
1266         /* If the cpu is not capable of doing dual channels don't do dual channels */
1267         nbcap = pci_read_config32(ctrl->f3, NORTHBRIDGE_CAP);
1268         if (!(nbcap & NBCAP_128Bit)) {
1269                 goto single_channel;
1270         }
1271         for(i = 0; (i < 4) && (ctrl->channel0[i]); i++) {
1272                 unsigned device0, device1;
1273                 int value0, value1;
1274                 int j;
1275                 /* If I don't have a dimm skip this one */
1276                 if (!(dimm_mask & (1 << i))) {
1277                         continue;
1278                 }
1279                 device0 = ctrl->channel0[i];
1280                 device1 = ctrl->channel1[i];
1281                 for(j = 0; j < sizeof(addresses)/sizeof(addresses[0]); j++) {
1282                         unsigned addr;
1283                         addr = addresses[j];
1284                         value0 = spd_read_byte(device0, addr);
1285                         if (value0 < 0) {
1286                                 return -1;
1287                         }
1288                         value1 = spd_read_byte(device1, addr);
1289                         if (value1 < 0) {
1290                                 return -1;
1291                         }
1292                         if (value0 != value1) {
1293                                 goto single_channel;
1294                         }
1295                 }
1296         }
1297         print_spew("Enabling dual channel memory\r\n");
1298         uint32_t dcl;
1299         dcl = pci_read_config32(ctrl->f2, DRAM_CONFIG_LOW);
1300         dcl &= ~DCL_32ByteEn;
1301         dcl |= DCL_128BitEn;
1302         pci_write_config32(ctrl->f2, DRAM_CONFIG_LOW, dcl);
1303         return dimm_mask;
1304  single_channel:
1305         dimm_mask &= ~((1 << (DIMM_SOCKETS *2)) - (1 << DIMM_SOCKETS));
1306         return dimm_mask;
1307 }
1308
1309 struct mem_param {
1310         uint8_t cycle_time;
1311         uint8_t divisor; /* In 1/2 ns increments */
1312         uint8_t tRC;
1313         uint8_t tRFC;
1314         uint32_t dch_memclk;
1315         uint16_t dch_tref4k, dch_tref8k;
1316         uint8_t  dtl_twr;
1317         char name[9];
1318 };
1319
1320 static const struct mem_param *get_mem_param(unsigned min_cycle_time)
1321 {
1322         static const struct mem_param speed[] = {
1323                 {
1324                         .name       = "100Mhz\r\n",
1325                         .cycle_time = 0xa0,
1326                         .divisor    = (10 <<1),
1327                         .tRC        = 0x46,
1328                         .tRFC       = 0x50,
1329                         .dch_memclk = DCH_MEMCLK_100MHZ << DCH_MEMCLK_SHIFT,
1330                         .dch_tref4k = DTH_TREF_100MHZ_4K,
1331                         .dch_tref8k = DTH_TREF_100MHZ_8K,
1332                         .dtl_twr    = 2,
1333                 },
1334                 {
1335                         .name       = "133Mhz\r\n",
1336                         .cycle_time = 0x75,
1337                         .divisor    = (7<<1)+1,
1338                         .tRC        = 0x41,
1339                         .tRFC       = 0x4B,
1340                         .dch_memclk = DCH_MEMCLK_133MHZ << DCH_MEMCLK_SHIFT,
1341                         .dch_tref4k = DTH_TREF_133MHZ_4K,
1342                         .dch_tref8k = DTH_TREF_133MHZ_8K,
1343                         .dtl_twr    = 2,
1344                 },
1345                 {
1346                         .name       = "166Mhz\r\n",
1347                         .cycle_time = 0x60,
1348                         .divisor    = (6<<1),
1349                         .tRC        = 0x3C,
1350                         .tRFC       = 0x48,
1351                         .dch_memclk = DCH_MEMCLK_166MHZ << DCH_MEMCLK_SHIFT,
1352                         .dch_tref4k = DTH_TREF_166MHZ_4K,
1353                         .dch_tref8k = DTH_TREF_166MHZ_8K,
1354                         .dtl_twr    = 3,
1355                 },
1356                 {
1357                         .name       = "200Mhz\r\n",
1358                         .cycle_time = 0x50,
1359                         .divisor    = (5<<1),
1360                         .tRC        = 0x37,
1361                         .tRFC       = 0x46,
1362                         .dch_memclk = DCH_MEMCLK_200MHZ << DCH_MEMCLK_SHIFT,
1363                         .dch_tref4k = DTH_TREF_200MHZ_4K,
1364                         .dch_tref8k = DTH_TREF_200MHZ_8K,
1365                         .dtl_twr    = 3,
1366                 },
1367                 {
1368                         .cycle_time = 0x00,
1369                 },
1370         };
1371         const struct mem_param *param;
1372         for(param = &speed[0]; param->cycle_time ; param++) {
1373                 if (min_cycle_time > (param+1)->cycle_time) {
1374                         break;
1375                 }
1376         }
1377         if (!param->cycle_time) {
1378                 die("min_cycle_time to low");
1379         }
1380         print_spew(param->name);
1381 #ifdef DRAM_MIN_CYCLE_TIME
1382         print_debug(param->name);
1383 #endif
1384         return param;
1385 }
1386
1387 struct spd_set_memclk_result {
1388         const struct mem_param *param;
1389         long dimm_mask;
1390 };
1391 static struct spd_set_memclk_result spd_set_memclk(const struct mem_controller *ctrl, long dimm_mask)
1392 {
1393         /* Compute the minimum cycle time for these dimms */
1394         struct spd_set_memclk_result result;
1395         unsigned min_cycle_time, min_latency, bios_cycle_time;
1396         int i;
1397         uint32_t value;
1398
1399         static const uint8_t latency_indicies[] = { 26, 23, 9 };
1400         static const unsigned char min_cycle_times[] = {
1401                 [NBCAP_MEMCLK_200MHZ] = 0x50, /* 5ns */
1402                 [NBCAP_MEMCLK_166MHZ] = 0x60, /* 6ns */
1403                 [NBCAP_MEMCLK_133MHZ] = 0x75, /* 7.5ns */
1404                 [NBCAP_MEMCLK_100MHZ] = 0xa0, /* 10ns */
1405         };
1406
1407
1408         value = pci_read_config32(ctrl->f3, NORTHBRIDGE_CAP);
1409         min_cycle_time = min_cycle_times[(value >> NBCAP_MEMCLK_SHIFT) & NBCAP_MEMCLK_MASK];
1410         bios_cycle_time = min_cycle_times[
1411                 read_option(CMOS_VSTART_max_mem_clock, CMOS_VLEN_max_mem_clock, 0)];
1412         if (bios_cycle_time > min_cycle_time) {
1413                 min_cycle_time = bios_cycle_time;
1414         }
1415         min_latency = 2;
1416
1417         /* Compute the least latency with the fastest clock supported
1418          * by both the memory controller and the dimms.
1419          */
1420         for(i = 0; i < DIMM_SOCKETS; i++) {
1421                 int new_cycle_time, new_latency;
1422                 int index;
1423                 int latencies;
1424                 int latency;
1425
1426                 if (!(dimm_mask & (1 << i))) {
1427                         continue;
1428                 }
1429
1430                 /* First find the supported CAS latencies
1431                  * Byte 18 for DDR SDRAM is interpreted:
1432                  * bit 0 == CAS Latency = 1.0
1433                  * bit 1 == CAS Latency = 1.5
1434                  * bit 2 == CAS Latency = 2.0
1435                  * bit 3 == CAS Latency = 2.5
1436                  * bit 4 == CAS Latency = 3.0
1437                  * bit 5 == CAS Latency = 3.5
1438                  * bit 6 == TBD
1439                  * bit 7 == TBD
1440                  */
1441                 new_cycle_time = 0xa0;
1442                 new_latency = 5;
1443
1444                 latencies = spd_read_byte(ctrl->channel0[i], 18);
1445                 if (latencies <= 0) continue;
1446
1447                 /* Compute the lowest cas latency supported */
1448                 latency = log2(latencies) -2;
1449
1450                 /* Loop through and find a fast clock with a low latency */
1451                 for(index = 0; index < 3; index++, latency++) {
1452                         int value;
1453                         if ((latency < 2) || (latency > 4) ||
1454                                 (!(latencies & (1 << latency)))) {
1455                                 continue;
1456                         }
1457                         value = spd_read_byte(ctrl->channel0[i], latency_indicies[index]);
1458                         if (value < 0) {
1459                                 goto hw_error;
1460                         }
1461
1462                         /* Only increase the latency if we decreas the clock */
1463                         if ((value >= min_cycle_time) && (value < new_cycle_time)) {
1464                                 new_cycle_time = value;
1465                                 new_latency = latency;
1466                         }
1467                 }
1468                 if (new_latency > 4){
1469                         continue;
1470                 }
1471                 /* Does min_latency need to be increased? */
1472                 if (new_cycle_time > min_cycle_time) {
1473                         min_cycle_time = new_cycle_time;
1474                 }
1475                 /* Does min_cycle_time need to be increased? */
1476                 if (new_latency > min_latency) {
1477                         min_latency = new_latency;
1478                 }
1479         }
1480         /* Make a second pass through the dimms and disable
1481          * any that cannot support the selected memclk and cas latency.
1482          */
1483
1484         for(i = 0; (i < 4) && (ctrl->channel0[i]); i++) {
1485                 int latencies;
1486                 int latency;
1487                 int index;
1488                 int value;
1489                 if (!(dimm_mask & (1 << i))) {
1490                         continue;
1491                 }
1492                 latencies = spd_read_byte(ctrl->channel0[i], 18);
1493                 if (latencies < 0) goto hw_error;
1494                 if (latencies == 0) {
1495                         goto dimm_err;
1496                 }
1497
1498                 /* Compute the lowest cas latency supported */
1499                 latency = log2(latencies) -2;
1500
1501                 /* Walk through searching for the selected latency */
1502                 for(index = 0; index < 3; index++, latency++) {
1503                         if (!(latencies & (1 << latency))) {
1504                                 continue;
1505                         }
1506                         if (latency == min_latency)
1507                                 break;
1508                 }
1509                 /* If I can't find the latency or my index is bad error */
1510                 if ((latency != min_latency) || (index >= 3)) {
1511                         goto dimm_err;
1512                 }
1513
1514                 /* Read the min_cycle_time for this latency */
1515                 value = spd_read_byte(ctrl->channel0[i], latency_indicies[index]);
1516                 if (value < 0) goto hw_error;
1517
1518                 /* All is good if the selected clock speed
1519                  * is what I need or slower.
1520                  */
1521                 if (value <= min_cycle_time) {
1522                         continue;
1523                 }
1524                 /* Otherwise I have an error, disable the dimm */
1525         dimm_err:
1526                 dimm_mask = disable_dimm(ctrl, i, dimm_mask);
1527         }
1528 #if 0
1529 //down speed for full load 4 rank support
1530 #if K8_4RANK_DIMM_SUPPORT
1531         if(dimm_mask == (3|(3<<DIMM_SOCKETS)) ) {
1532                 int ranks = 4;
1533                 for(i = 0; (i < 4) && (ctrl->channel0[i]); i++) {
1534                         int val;
1535                         if (!(dimm_mask & (1 << i))) {
1536                                 continue;
1537                         }
1538                         val = spd_read_byte(ctrl->channel0[i], 5);
1539                         if(val!=ranks) {
1540                                 ranks = val;
1541                                 break;
1542                         }
1543                 }
1544                 if(ranks==4) {
1545                         if(min_cycle_time <= 0x50 ) {
1546                                 min_cycle_time = 0x60;
1547                         }
1548                 }
1549
1550         }
1551 #endif
1552 #endif
1553         /* Now that I know the minimum cycle time lookup the memory parameters */
1554         result.param = get_mem_param(min_cycle_time);
1555
1556         /* Update DRAM Config High with our selected memory speed */
1557         value = pci_read_config32(ctrl->f2, DRAM_CONFIG_HIGH);
1558         value &= ~(DCH_MEMCLK_MASK << DCH_MEMCLK_SHIFT);
1559 #if 0
1560         /* Improves DQS centering by correcting for case when core speed multiplier and MEMCLK speed result in odd clock divisor, by selecting the next lowest memory speed, required only at DDR400 and higher speeds with certain DIMM loadings ---- cheating???*/
1561         if(!is_cpu_pre_e0()) {
1562                 if(min_cycle_time==0x50) {
1563                         value |= 1<<31;
1564                 }
1565         }
1566 #endif
1567
1568         value |= result.param->dch_memclk;
1569         pci_write_config32(ctrl->f2, DRAM_CONFIG_HIGH, value);
1570
1571         static const unsigned latencies[] = { DTL_CL_2, DTL_CL_2_5, DTL_CL_3 };
1572         /* Update DRAM Timing Low with our selected cas latency */
1573         value = pci_read_config32(ctrl->f2, DRAM_TIMING_LOW);
1574         value &= ~(DTL_TCL_MASK << DTL_TCL_SHIFT);
1575         value |= latencies[min_latency - 2] << DTL_TCL_SHIFT;
1576         pci_write_config32(ctrl->f2, DRAM_TIMING_LOW, value);
1577
1578         result.dimm_mask = dimm_mask;
1579         return result;
1580  hw_error:
1581         result.param = (const struct mem_param *)0;
1582         result.dimm_mask = -1;
1583         return result;
1584 }
1585
1586
1587 static int update_dimm_Trc(const struct mem_controller *ctrl, const struct mem_param *param, int i)
1588 {
1589         unsigned clocks, old_clocks;
1590         uint32_t dtl;
1591         int value;
1592         value = spd_read_byte(ctrl->channel0[i], 41);
1593         if (value < 0) return -1;
1594         if ((value == 0) || (value == 0xff)) {
1595                 value = param->tRC;
1596         }
1597         clocks = ((value << 1) + param->divisor - 1)/param->divisor;
1598         if (clocks < DTL_TRC_MIN) {
1599                 clocks = DTL_TRC_MIN;
1600         }
1601         if (clocks > DTL_TRC_MAX) {
1602                 return 0;
1603         }
1604
1605         dtl = pci_read_config32(ctrl->f2, DRAM_TIMING_LOW);
1606         old_clocks = ((dtl >> DTL_TRC_SHIFT) & DTL_TRC_MASK) + DTL_TRC_BASE;
1607         if (old_clocks > clocks) {
1608                 clocks = old_clocks;
1609         }
1610         dtl &= ~(DTL_TRC_MASK << DTL_TRC_SHIFT);
1611         dtl |=  ((clocks - DTL_TRC_BASE) << DTL_TRC_SHIFT);
1612         pci_write_config32(ctrl->f2, DRAM_TIMING_LOW, dtl);
1613         return 1;
1614 }
1615
1616 static int update_dimm_Trfc(const struct mem_controller *ctrl, const struct mem_param *param, int i)
1617 {
1618         unsigned clocks, old_clocks;
1619         uint32_t dtl;
1620         int value;
1621         value = spd_read_byte(ctrl->channel0[i], 42);
1622         if (value < 0) return -1;
1623         if ((value == 0) || (value == 0xff)) {
1624                 value = param->tRFC;
1625         }
1626         clocks = ((value << 1) + param->divisor - 1)/param->divisor;
1627         if (clocks < DTL_TRFC_MIN) {
1628                 clocks = DTL_TRFC_MIN;
1629         }
1630         if (clocks > DTL_TRFC_MAX) {
1631                 return 0;
1632         }
1633         dtl = pci_read_config32(ctrl->f2, DRAM_TIMING_LOW);
1634         old_clocks = ((dtl >> DTL_TRFC_SHIFT) & DTL_TRFC_MASK) + DTL_TRFC_BASE;
1635         if (old_clocks > clocks) {
1636                 clocks = old_clocks;
1637         }
1638         dtl &= ~(DTL_TRFC_MASK << DTL_TRFC_SHIFT);
1639         dtl |= ((clocks - DTL_TRFC_BASE) << DTL_TRFC_SHIFT);
1640         pci_write_config32(ctrl->f2, DRAM_TIMING_LOW, dtl);
1641         return 1;
1642 }
1643
1644
1645 static int update_dimm_Trcd(const struct mem_controller *ctrl, const struct mem_param *param, int i)
1646 {
1647         unsigned clocks, old_clocks;
1648         uint32_t dtl;
1649         int value;
1650         value = spd_read_byte(ctrl->channel0[i], 29);
1651         if (value < 0) return -1;
1652         clocks = (value + (param->divisor << 1) -1)/(param->divisor << 1);
1653         if (clocks < DTL_TRCD_MIN) {
1654                 clocks = DTL_TRCD_MIN;
1655         }
1656         if (clocks > DTL_TRCD_MAX) {
1657                 return 0;
1658         }
1659         dtl = pci_read_config32(ctrl->f2, DRAM_TIMING_LOW);
1660         old_clocks = ((dtl >> DTL_TRCD_SHIFT) & DTL_TRCD_MASK) + DTL_TRCD_BASE;
1661         if (old_clocks > clocks) {
1662                 clocks = old_clocks;
1663         }
1664         dtl &= ~(DTL_TRCD_MASK << DTL_TRCD_SHIFT);
1665         dtl |= ((clocks - DTL_TRCD_BASE) << DTL_TRCD_SHIFT);
1666         pci_write_config32(ctrl->f2, DRAM_TIMING_LOW, dtl);
1667         return 1;
1668 }
1669
1670 static int update_dimm_Trrd(const struct mem_controller *ctrl, const struct mem_param *param, int i)
1671 {
1672         unsigned clocks, old_clocks;
1673         uint32_t dtl;
1674         int value;
1675         value = spd_read_byte(ctrl->channel0[i], 28);
1676         if (value < 0) return -1;
1677         clocks = (value + (param->divisor << 1) -1)/(param->divisor << 1);
1678         if (clocks < DTL_TRRD_MIN) {
1679                 clocks = DTL_TRRD_MIN;
1680         }
1681         if (clocks > DTL_TRRD_MAX) {
1682                 return 0;
1683         }
1684         dtl = pci_read_config32(ctrl->f2, DRAM_TIMING_LOW);
1685         old_clocks = ((dtl >> DTL_TRRD_SHIFT) & DTL_TRRD_MASK) + DTL_TRRD_BASE;
1686         if (old_clocks > clocks) {
1687                 clocks = old_clocks;
1688         }
1689         dtl &= ~(DTL_TRRD_MASK << DTL_TRRD_SHIFT);
1690         dtl |= ((clocks - DTL_TRRD_BASE) << DTL_TRRD_SHIFT);
1691         pci_write_config32(ctrl->f2, DRAM_TIMING_LOW, dtl);
1692         return 1;
1693 }
1694
1695 static int update_dimm_Tras(const struct mem_controller *ctrl, const struct mem_param *param, int i)
1696 {
1697         unsigned clocks, old_clocks;
1698         uint32_t dtl;
1699         int value;
1700         value = spd_read_byte(ctrl->channel0[i], 30);
1701         if (value < 0) return -1;
1702         clocks = ((value << 1) + param->divisor - 1)/param->divisor;
1703         if (clocks < DTL_TRAS_MIN) {
1704                 clocks = DTL_TRAS_MIN;
1705         }
1706         if (clocks > DTL_TRAS_MAX) {
1707                 return 0;
1708         }
1709         dtl = pci_read_config32(ctrl->f2, DRAM_TIMING_LOW);
1710         old_clocks = ((dtl >> DTL_TRAS_SHIFT) & DTL_TRAS_MASK) + DTL_TRAS_BASE;
1711         if (old_clocks > clocks) {
1712                 clocks = old_clocks;
1713         }
1714         dtl &= ~(DTL_TRAS_MASK << DTL_TRAS_SHIFT);
1715         dtl |= ((clocks - DTL_TRAS_BASE) << DTL_TRAS_SHIFT);
1716         pci_write_config32(ctrl->f2, DRAM_TIMING_LOW, dtl);
1717         return 1;
1718 }
1719
1720 static int update_dimm_Trp(const struct mem_controller *ctrl, const struct mem_param *param, int i)
1721 {
1722         unsigned clocks, old_clocks;
1723         uint32_t dtl;
1724         int value;
1725         value = spd_read_byte(ctrl->channel0[i], 27);
1726         if (value < 0) return -1;
1727         clocks = (value + (param->divisor << 1) - 1)/(param->divisor << 1);
1728         if (clocks < DTL_TRP_MIN) {
1729                 clocks = DTL_TRP_MIN;
1730         }
1731         if (clocks > DTL_TRP_MAX) {
1732                 return 0;
1733         }
1734         dtl = pci_read_config32(ctrl->f2, DRAM_TIMING_LOW);
1735         old_clocks = ((dtl >> DTL_TRP_SHIFT) & DTL_TRP_MASK) + DTL_TRP_BASE;
1736         if (old_clocks > clocks) {
1737                 clocks = old_clocks;
1738         }
1739         dtl &= ~(DTL_TRP_MASK << DTL_TRP_SHIFT);
1740         dtl |= ((clocks - DTL_TRP_BASE) << DTL_TRP_SHIFT);
1741         pci_write_config32(ctrl->f2, DRAM_TIMING_LOW, dtl);
1742         return 1;
1743 }
1744
1745 static void set_Twr(const struct mem_controller *ctrl, const struct mem_param *param)
1746 {
1747         uint32_t dtl;
1748         dtl = pci_read_config32(ctrl->f2, DRAM_TIMING_LOW);
1749         dtl &= ~(DTL_TWR_MASK << DTL_TWR_SHIFT);
1750         dtl |= (param->dtl_twr - DTL_TWR_BASE) << DTL_TWR_SHIFT;
1751         pci_write_config32(ctrl->f2, DRAM_TIMING_LOW, dtl);
1752 }
1753
1754
1755 static void init_Tref(const struct mem_controller *ctrl, const struct mem_param *param)
1756 {
1757         uint32_t dth;
1758         dth = pci_read_config32(ctrl->f2, DRAM_TIMING_HIGH);
1759         dth &= ~(DTH_TREF_MASK << DTH_TREF_SHIFT);
1760         dth |= (param->dch_tref4k << DTH_TREF_SHIFT);
1761         pci_write_config32(ctrl->f2, DRAM_TIMING_HIGH, dth);
1762 }
1763
1764 static int update_dimm_Tref(const struct mem_controller *ctrl, const struct mem_param *param, int i)
1765 {
1766         uint32_t dth;
1767         int value;
1768         unsigned tref, old_tref;
1769         value = spd_read_byte(ctrl->channel0[i], 3);
1770         if (value < 0) return -1;
1771         value &= 0xf;
1772
1773         tref = param->dch_tref8k;
1774         if (value == 12) {
1775                 tref = param->dch_tref4k;
1776         }
1777
1778         dth = pci_read_config32(ctrl->f2, DRAM_TIMING_HIGH);
1779         old_tref = (dth >> DTH_TREF_SHIFT) & DTH_TREF_MASK;
1780         if ((value == 12) && (old_tref == param->dch_tref4k)) {
1781                 tref = param->dch_tref4k;
1782         } else {
1783                 tref = param->dch_tref8k;
1784         }
1785         dth &= ~(DTH_TREF_MASK << DTH_TREF_SHIFT);
1786         dth |= (tref << DTH_TREF_SHIFT);
1787         pci_write_config32(ctrl->f2, DRAM_TIMING_HIGH, dth);
1788         return 1;
1789 }
1790
1791
1792 static int update_dimm_x4(const struct mem_controller *ctrl, const struct mem_param *param, int i)
1793 {
1794         uint32_t dcl;
1795         int value;
1796 #if K8_4RANK_DIMM_SUPPORT == 1
1797         int rank;
1798 #endif
1799         int dimm;
1800         value = spd_read_byte(ctrl->channel0[i], 13);
1801         if (value < 0) {
1802                 return -1;
1803         }
1804
1805 #if K8_4RANK_DIMM_SUPPORT == 1
1806         rank = spd_read_byte(ctrl->channel0[i], 5);       /* number of physical banks */
1807         if (rank < 0) {
1808                 return -1;
1809         }
1810 #endif
1811
1812         dimm = 1<<(DCL_x4DIMM_SHIFT+i);
1813 #if K8_4RANK_DIMM_SUPPORT == 1
1814         if(rank==4) {
1815                 dimm |= 1<<(DCL_x4DIMM_SHIFT+i+2);
1816         }
1817 #endif
1818         dcl = pci_read_config32(ctrl->f2, DRAM_CONFIG_LOW);
1819         dcl &= ~dimm;
1820         if (value == 4) {
1821                 dcl |= dimm;
1822         }
1823         pci_write_config32(ctrl->f2, DRAM_CONFIG_LOW, dcl);
1824         return 1;
1825 }
1826
1827 static int update_dimm_ecc(const struct mem_controller *ctrl, const struct mem_param *param, int i)
1828 {
1829         uint32_t dcl;
1830         int value;
1831         value = spd_read_byte(ctrl->channel0[i], 11);
1832         if (value < 0) {
1833                 return -1;
1834         }
1835         if (value != 2) {
1836                 dcl = pci_read_config32(ctrl->f2, DRAM_CONFIG_LOW);
1837                 dcl &= ~DCL_DimmEccEn;
1838                 pci_write_config32(ctrl->f2, DRAM_CONFIG_LOW, dcl);
1839         }
1840         return 1;
1841 }
1842
1843 static int count_dimms(const struct mem_controller *ctrl)
1844 {
1845         int dimms;
1846         unsigned index;
1847         dimms = 0;
1848         for(index = 0; index < 8; index += 2) {
1849                 uint32_t csbase;
1850                 csbase = pci_read_config32(ctrl->f2, (DRAM_CSBASE + (index << 2)));
1851                 if (csbase & 1) {
1852                         dimms += 1;
1853                 }
1854         }
1855         return dimms;
1856 }
1857
1858 static void set_Twtr(const struct mem_controller *ctrl, const struct mem_param *param)
1859 {
1860         uint32_t dth;
1861         unsigned clocks;
1862         clocks = 1; /* AMD says hard code this */
1863         dth = pci_read_config32(ctrl->f2, DRAM_TIMING_HIGH);
1864         dth &= ~(DTH_TWTR_MASK << DTH_TWTR_SHIFT);
1865         dth |= ((clocks - DTH_TWTR_BASE) << DTH_TWTR_SHIFT);
1866         pci_write_config32(ctrl->f2, DRAM_TIMING_HIGH, dth);
1867 }
1868
1869 static void set_Trwt(const struct mem_controller *ctrl, const struct mem_param *param)
1870 {
1871         uint32_t dth, dtl;
1872         unsigned divisor;
1873         unsigned latency;
1874         unsigned clocks;
1875
1876         clocks = 0;
1877         dtl = pci_read_config32(ctrl->f2, DRAM_TIMING_LOW);
1878         latency = (dtl >> DTL_TCL_SHIFT) & DTL_TCL_MASK;
1879         divisor = param->divisor;
1880
1881         if (is_opteron(ctrl)) {
1882                 if (latency == DTL_CL_2) {
1883                         if (divisor == ((6 << 0) + 0)) {
1884                                 /* 166Mhz */
1885                                 clocks = 3;
1886                         }
1887                         else if (divisor > ((6 << 0)+0)) {
1888                                 /* 100Mhz && 133Mhz */
1889                                 clocks = 2;
1890                         }
1891                 }
1892                 else if (latency == DTL_CL_2_5) {
1893                         clocks = 3;
1894                 }
1895                 else if (latency == DTL_CL_3) {
1896                         if (divisor == ((6 << 0)+0)) {
1897                                 /* 166Mhz */
1898                                 clocks = 4;
1899                         }
1900                         else if (divisor > ((6 << 0)+0)) {
1901                                 /* 100Mhz && 133Mhz */
1902                                 clocks = 3;
1903                         }
1904                 }
1905         }
1906         else /* Athlon64 */ {
1907                 if (is_registered(ctrl)) {
1908                         if (latency == DTL_CL_2) {
1909                                 clocks = 2;
1910                         }
1911                         else if (latency == DTL_CL_2_5) {
1912                                 clocks = 3;
1913                         }
1914                         else if (latency == DTL_CL_3) {
1915                                 clocks = 3;
1916                         }
1917                 }
1918                 else /* Unbuffered */{
1919                         if (latency == DTL_CL_2) {
1920                                 clocks = 3;
1921                         }
1922                         else if (latency == DTL_CL_2_5) {
1923                                 clocks = 4;
1924                         }
1925                         else if (latency == DTL_CL_3) {
1926                                 clocks = 4;
1927                         }
1928                 }
1929         }
1930         if ((clocks < DTH_TRWT_MIN) || (clocks > DTH_TRWT_MAX)) {
1931                 die("Unknown Trwt\r\n");
1932         }
1933
1934         dth = pci_read_config32(ctrl->f2, DRAM_TIMING_HIGH);
1935         dth &= ~(DTH_TRWT_MASK << DTH_TRWT_SHIFT);
1936         dth |= ((clocks - DTH_TRWT_BASE) << DTH_TRWT_SHIFT);
1937         pci_write_config32(ctrl->f2, DRAM_TIMING_HIGH, dth);
1938         return;
1939 }
1940
1941 static void set_Twcl(const struct mem_controller *ctrl, const struct mem_param *param)
1942 {
1943         /* Memory Clocks after CAS# */
1944         uint32_t dth;
1945         unsigned clocks;
1946         if (is_registered(ctrl)) {
1947                 clocks = 2;
1948         } else {
1949                 clocks = 1;
1950         }
1951         dth = pci_read_config32(ctrl->f2, DRAM_TIMING_HIGH);
1952         dth &= ~(DTH_TWCL_MASK << DTH_TWCL_SHIFT);
1953         dth |= ((clocks - DTH_TWCL_BASE) << DTH_TWCL_SHIFT);
1954         pci_write_config32(ctrl->f2, DRAM_TIMING_HIGH, dth);
1955 }
1956
1957
1958 static void set_read_preamble(const struct mem_controller *ctrl, const struct mem_param *param)
1959 {
1960         uint32_t dch;
1961         unsigned divisor;
1962         unsigned rdpreamble;
1963         divisor = param->divisor;
1964         dch = pci_read_config32(ctrl->f2, DRAM_CONFIG_HIGH);
1965         dch &= ~(DCH_RDPREAMBLE_MASK << DCH_RDPREAMBLE_SHIFT);
1966         rdpreamble = 0;
1967         if (is_registered(ctrl)) {
1968                 if (divisor == ((10 << 1)+0)) {
1969                         /* 100Mhz, 9ns */
1970                         rdpreamble = ((9 << 1)+ 0);
1971                 }
1972                 else if (divisor == ((7 << 1)+1)) {
1973                         /* 133Mhz, 8ns */
1974                         rdpreamble = ((8 << 1)+0);
1975                 }
1976                 else if (divisor == ((6 << 1)+0)) {
1977                         /* 166Mhz, 7.5ns */
1978                         rdpreamble = ((7 << 1)+1);
1979                 }
1980                 else if (divisor == ((5 << 1)+0)) {
1981                         /* 200Mhz,  7ns */
1982                         rdpreamble = ((7 << 1)+0);
1983                 }
1984         }
1985         else {
1986                 int slots;
1987                 int i;
1988                 slots = 0;
1989                 for(i = 0; i < 4; i++) {
1990                         if (ctrl->channel0[i]) {
1991                                 slots += 1;
1992                         }
1993                 }
1994                 if (divisor == ((10 << 1)+0)) {
1995                         /* 100Mhz */
1996                         if (slots <= 2) {
1997                                 /* 9ns */
1998                                 rdpreamble = ((9 << 1)+0);
1999                         } else {
2000                                 /* 14ns */
2001                                 rdpreamble = ((14 << 1)+0);
2002                         }
2003                 }
2004                 else if (divisor == ((7 << 1)+1)) {
2005                         /* 133Mhz */
2006                         if (slots <= 2) {
2007                                 /* 7ns */
2008                                 rdpreamble = ((7 << 1)+0);
2009                         } else {
2010                                 /* 11 ns */
2011                                 rdpreamble = ((11 << 1)+0);
2012                         }
2013                 }
2014                 else if (divisor == ((6 << 1)+0)) {
2015                         /* 166Mhz */
2016                         if (slots <= 2) {
2017                                 /* 6ns */
2018                                 rdpreamble = ((7 << 1)+0);
2019                         } else {
2020                                 /* 9ns */
2021                                 rdpreamble = ((9 << 1)+0);
2022                         }
2023                 }
2024                 else if (divisor == ((5 << 1)+0)) {
2025                         /* 200Mhz */
2026                         if (slots <= 2) {
2027                                 /* 5ns */
2028                                 rdpreamble = ((5 << 1)+0);
2029                         } else {
2030                                 /* 7ns */
2031                                 rdpreamble = ((7 << 1)+0);
2032                         }
2033                 }
2034         }
2035         if ((rdpreamble < DCH_RDPREAMBLE_MIN) || (rdpreamble > DCH_RDPREAMBLE_MAX)) {
2036                 die("Unknown rdpreamble");
2037         }
2038         dch |= (rdpreamble - DCH_RDPREAMBLE_BASE) << DCH_RDPREAMBLE_SHIFT;
2039         pci_write_config32(ctrl->f2, DRAM_CONFIG_HIGH, dch);
2040 }
2041
2042 static void set_max_async_latency(const struct mem_controller *ctrl, const struct mem_param *param)
2043 {
2044         uint32_t dch;
2045         unsigned async_lat;
2046         int dimms;
2047
2048         dimms = count_dimms(ctrl);
2049
2050         dch = pci_read_config32(ctrl->f2, DRAM_CONFIG_HIGH);
2051         dch &= ~(DCH_ASYNC_LAT_MASK << DCH_ASYNC_LAT_SHIFT);
2052         async_lat = 0;
2053         if (is_registered(ctrl)) {
2054                 if (dimms == 4) {
2055                         /* 9ns */
2056                         async_lat = 9;
2057                 }
2058                 else {
2059                         /* 8ns */
2060                         async_lat = 8;
2061                 }
2062         }
2063         else {
2064                 if (dimms > 3) {
2065                         die("Too many unbuffered dimms");
2066                 }
2067                 else if (dimms == 3) {
2068                         /* 7ns */
2069                         async_lat = 7;
2070                 }
2071                 else {
2072                         /* 6ns */
2073                         async_lat = 6;
2074                 }
2075         }
2076         dch |= ((async_lat - DCH_ASYNC_LAT_BASE) << DCH_ASYNC_LAT_SHIFT);
2077         pci_write_config32(ctrl->f2, DRAM_CONFIG_HIGH, dch);
2078 }
2079
2080 static void set_idle_cycle_limit(const struct mem_controller *ctrl, const struct mem_param *param)
2081 {
2082         uint32_t dch;
2083         /* AMD says to Hardcode this */
2084         dch = pci_read_config32(ctrl->f2, DRAM_CONFIG_HIGH);
2085         dch &= ~(DCH_IDLE_LIMIT_MASK << DCH_IDLE_LIMIT_SHIFT);
2086         dch |= DCH_IDLE_LIMIT_16 << DCH_IDLE_LIMIT_SHIFT;
2087         dch |= DCH_DYN_IDLE_CTR_EN;
2088         pci_write_config32(ctrl->f2, DRAM_CONFIG_HIGH, dch);
2089 }
2090
2091 static long spd_set_dram_timing(const struct mem_controller *ctrl, const struct mem_param *param, long dimm_mask)
2092 {
2093         int i;
2094
2095         init_Tref(ctrl, param);
2096         for(i = 0; i < DIMM_SOCKETS; i++) {
2097                 int rc;
2098                 if (!(dimm_mask & (1 << i))) {
2099                         continue;
2100                 }
2101                 /* DRAM Timing Low Register */
2102                 if ((rc = update_dimm_Trc (ctrl, param, i)) <= 0) goto dimm_err;
2103                 if ((rc = update_dimm_Trfc(ctrl, param, i)) <= 0) goto dimm_err;
2104                 if ((rc = update_dimm_Trcd(ctrl, param, i)) <= 0) goto dimm_err;
2105                 if ((rc = update_dimm_Trrd(ctrl, param, i)) <= 0) goto dimm_err;
2106                 if ((rc = update_dimm_Tras(ctrl, param, i)) <= 0) goto dimm_err;
2107                 if ((rc = update_dimm_Trp (ctrl, param, i)) <= 0) goto dimm_err;
2108
2109                 /* DRAM Timing High Register */
2110                 if ((rc = update_dimm_Tref(ctrl, param, i)) <= 0) goto dimm_err;
2111
2112
2113                 /* DRAM Config Low */
2114                 if ((rc = update_dimm_x4 (ctrl, param, i)) <= 0) goto dimm_err;
2115                 if ((rc = update_dimm_ecc(ctrl, param, i)) <= 0) goto dimm_err;
2116                 continue;
2117         dimm_err:
2118                 if (rc < 0) {
2119                         return -1;
2120                 }
2121                 dimm_mask = disable_dimm(ctrl, i, dimm_mask);
2122         }
2123         /* DRAM Timing Low Register */
2124         set_Twr(ctrl, param);
2125
2126         /* DRAM Timing High Register */
2127         set_Twtr(ctrl, param);
2128         set_Trwt(ctrl, param);
2129         set_Twcl(ctrl, param);
2130
2131         /* DRAM Config High */
2132         set_read_preamble(ctrl, param);
2133         set_max_async_latency(ctrl, param);
2134         set_idle_cycle_limit(ctrl, param);
2135         return dimm_mask;
2136 }
2137
2138 static void sdram_set_spd_registers(const struct mem_controller *ctrl)
2139 {
2140         struct spd_set_memclk_result result;
2141         const struct mem_param *param;
2142         long dimm_mask;
2143 #if 1
2144         if (!controller_present(ctrl)) {
2145 //              print_debug("No memory controller present\r\n");
2146                 return;
2147         }
2148 #endif
2149         hw_enable_ecc(ctrl);
2150         activate_spd_rom(ctrl);
2151         dimm_mask = spd_detect_dimms(ctrl);
2152         if (!(dimm_mask & ((1 << DIMM_SOCKETS) - 1))) {
2153                 print_debug("No memory for this cpu\r\n");
2154                 return;
2155         }
2156         dimm_mask = spd_enable_2channels(ctrl, dimm_mask);
2157         if (dimm_mask < 0)
2158                 goto hw_spd_err;
2159         dimm_mask = spd_set_ram_size(ctrl , dimm_mask);
2160         if (dimm_mask < 0)
2161                 goto hw_spd_err;
2162         dimm_mask = spd_handle_unbuffered_dimms(ctrl, dimm_mask);
2163         if (dimm_mask < 0)
2164                 goto hw_spd_err;
2165         result = spd_set_memclk(ctrl, dimm_mask);
2166         param     = result.param;
2167         dimm_mask = result.dimm_mask;
2168         if (dimm_mask < 0)
2169                 goto hw_spd_err;
2170         dimm_mask = spd_set_dram_timing(ctrl, param , dimm_mask);
2171         if (dimm_mask < 0)
2172                 goto hw_spd_err;
2173         order_dimms(ctrl);
2174         return;
2175  hw_spd_err:
2176         /* Unrecoverable error reading SPD data */
2177         print_err("SPD error - reset\r\n");
2178         hard_reset();
2179         return;
2180 }
2181
2182 #if K8_HW_MEM_HOLE_SIZEK != 0
2183 static uint32_t hoist_memory(int controllers, const struct mem_controller *ctrl,unsigned hole_startk, int i)
2184 {
2185         int ii;
2186         uint32_t carry_over;
2187         device_t dev;
2188         uint32_t base, limit;
2189         uint32_t basek;
2190         uint32_t hoist;
2191         int j;
2192
2193         carry_over = (4*1024*1024) - hole_startk;
2194
2195         for(ii=controllers - 1;ii>i;ii--) {
2196                 base  = pci_read_config32(ctrl[0].f1, 0x40 + (ii << 3));
2197                 if ((base & ((1<<1)|(1<<0))) != ((1<<1)|(1<<0))) {
2198                         continue;
2199                 }
2200                 limit = pci_read_config32(ctrl[0].f1, 0x44 + (ii << 3));
2201                 for(j = 0; j < controllers; j++) {
2202                         pci_write_config32(ctrl[j].f1, 0x44 + (ii << 3), limit + (carry_over << 2));
2203                         pci_write_config32(ctrl[j].f1, 0x40 + (ii << 3), base + (carry_over << 2));
2204                 }
2205         }
2206         limit = pci_read_config32(ctrl[0].f1, 0x44 + (i << 3));
2207         for(j = 0; j < controllers; j++) {
2208                 pci_write_config32(ctrl[j].f1, 0x44 + (i << 3), limit + (carry_over << 2));
2209         }
2210         dev = ctrl[i].f1;
2211         base  = pci_read_config32(dev, 0x40 + (i << 3));
2212         basek  = (base & 0xffff0000) >> 2;
2213         if(basek == hole_startk) {
2214                 //don't need set memhole here, because hole off set will be 0, overflow
2215                 //so need to change base reg instead, new basek will be 4*1024*1024
2216                 base &= 0x0000ffff;
2217                 base |= (4*1024*1024)<<2;
2218                 for(j = 0; j < controllers; j++) {
2219                         pci_write_config32(ctrl[j].f1, 0x40 + (i<<3), base);
2220                 }
2221         }
2222         else {
2223                 hoist = /* hole start address */
2224                         ((hole_startk << 10) & 0xff000000) +
2225                         /* hole address to memory controller address */
2226                         (((basek + carry_over) >> 6) & 0x0000ff00) +
2227                         /* enable */
2228                         1;
2229                 pci_write_config32(dev, 0xf0, hoist);
2230         }
2231
2232         return carry_over;
2233 }
2234
2235 static void set_hw_mem_hole(int controllers, const struct mem_controller *ctrl)
2236 {
2237
2238         uint32_t hole_startk;
2239         int i;
2240
2241         hole_startk = 4*1024*1024 - K8_HW_MEM_HOLE_SIZEK;
2242
2243 #if K8_HW_MEM_HOLE_SIZE_AUTO_INC == 1
2244         //We need to double check if the hole_startk is valid, if it is equal to basek, we need to decrease it some
2245         uint32_t basek_pri;
2246         for(i=0; i<controllers; i++) {
2247                         uint32_t base;
2248                         unsigned base_k;
2249                         base  = pci_read_config32(ctrl[0].f1, 0x40 + (i << 3));
2250                         if ((base & ((1<<1)|(1<<0))) != ((1<<1)|(1<<0))) {
2251                                 continue;
2252                         }
2253                         base_k = (base & 0xffff0000) >> 2;
2254                         if(base_k == hole_startk) {
2255                                 hole_startk -= (base_k - basek_pri)>>1; // decrease mem hole startk to make sure it is on middle of privous node
2256                                 break; //only one hole
2257                         }
2258                         basek_pri = base_k;
2259         }
2260
2261 #endif
2262         //find node index that need do set hole
2263         for(i=0; i<controllers; i++) {
2264                         uint32_t base, limit;
2265                         unsigned base_k, limit_k;
2266                         base  = pci_read_config32(ctrl[0].f1, 0x40 + (i << 3));
2267                         if ((base & ((1<<1)|(1<<0))) != ((1<<1)|(1<<0))) {
2268                                 continue;
2269                         }
2270                         limit = pci_read_config32(ctrl[0].f1, 0x44 + (i << 3));
2271                         base_k = (base & 0xffff0000) >> 2;
2272                         limit_k = ((limit + 0x00010000) & 0xffff0000) >> 2;
2273                         if ((base_k <= hole_startk) && (limit_k > hole_startk)) {
2274                                 unsigned end_k;
2275                                 hoist_memory(controllers, ctrl, hole_startk, i);
2276                                 end_k = memory_end_k(ctrl, controllers);
2277                                 set_top_mem(end_k, hole_startk);
2278                                 break; //only one hole
2279                         }
2280         }
2281
2282 }
2283
2284 #endif
2285
2286 #define TIMEOUT_LOOPS 300000
2287 static void sdram_enable(int controllers, const struct mem_controller *ctrl)
2288 {
2289         int i;
2290
2291         /* Error if I don't have memory */
2292         if (memory_end_k(ctrl, controllers) == 0) {
2293                 die("No memory\r\n");
2294         }
2295
2296         /* Before enabling memory start the memory clocks */
2297         for(i = 0; i < controllers; i++) {
2298                 uint32_t dch;
2299                 if (!controller_present(ctrl + i))
2300                         continue;
2301                 dch = pci_read_config32(ctrl[i].f2, DRAM_CONFIG_HIGH);
2302                 if (dch & (DCH_MEMCLK_EN0|DCH_MEMCLK_EN1|DCH_MEMCLK_EN2|DCH_MEMCLK_EN3)) {
2303                         dch |= DCH_MEMCLK_VALID;
2304                         pci_write_config32(ctrl[i].f2, DRAM_CONFIG_HIGH, dch);
2305                 }
2306                 else {
2307                         /* Disable dram receivers */
2308                         uint32_t dcl;
2309                         dcl = pci_read_config32(ctrl[i].f2, DRAM_CONFIG_LOW);
2310                         dcl |= DCL_DisInRcvrs;
2311                         pci_write_config32(ctrl[i].f2, DRAM_CONFIG_LOW, dcl);
2312                 }
2313         }
2314
2315         /* And if necessary toggle the the reset on the dimms by hand */
2316         memreset(controllers, ctrl);
2317
2318         for(i = 0; i < controllers; i++) {
2319                 uint32_t dcl, dch;
2320                 if (!controller_present(ctrl + i))
2321                         continue;
2322                 /* Skip everything if I don't have any memory on this controller */
2323                 dch = pci_read_config32(ctrl[i].f2, DRAM_CONFIG_HIGH);
2324                 if (!(dch & DCH_MEMCLK_VALID)) {
2325                         continue;
2326                 }
2327
2328                 /* Toggle DisDqsHys to get it working */
2329                 dcl = pci_read_config32(ctrl[i].f2, DRAM_CONFIG_LOW);
2330                 if (dcl & DCL_DimmEccEn) {
2331                         uint32_t mnc;
2332                         print_spew("ECC enabled\r\n");
2333                         mnc = pci_read_config32(ctrl[i].f3, MCA_NB_CONFIG);
2334                         mnc |= MNC_ECC_EN;
2335                         if (dcl & DCL_128BitEn) {
2336                                 mnc |= MNC_CHIPKILL_EN;
2337                         }
2338                         pci_write_config32(ctrl[i].f3, MCA_NB_CONFIG, mnc);
2339                 }
2340                 dcl |= DCL_DisDqsHys;
2341                 pci_write_config32(ctrl[i].f2, DRAM_CONFIG_LOW, dcl);
2342                 dcl &= ~DCL_DisDqsHys;
2343                 dcl &= ~DCL_DLL_Disable;
2344                 dcl &= ~DCL_D_DRV;
2345                 dcl &= ~DCL_QFC_EN;
2346                 dcl |= DCL_DramInit;
2347                 pci_write_config32(ctrl[i].f2, DRAM_CONFIG_LOW, dcl);
2348
2349         }
2350         for(i = 0; i < controllers; i++) {
2351                 uint32_t dcl, dch;
2352                 if (!controller_present(ctrl + i))
2353                         continue;
2354                 /* Skip everything if I don't have any memory on this controller */
2355                 dch = pci_read_config32(ctrl[i].f2, DRAM_CONFIG_HIGH);
2356                 if (!(dch & DCH_MEMCLK_VALID)) {
2357                         continue;
2358                 }
2359
2360                 print_debug("Initializing memory: ");
2361
2362                 int loops = 0;
2363                 do {
2364                         dcl = pci_read_config32(ctrl[i].f2, DRAM_CONFIG_LOW);
2365                         loops += 1;
2366                         if ((loops & 1023) == 0) {
2367                                 print_debug(".");
2368                         }
2369                 } while(((dcl & DCL_DramInit) != 0) && (loops < TIMEOUT_LOOPS));
2370                 if (loops >= TIMEOUT_LOOPS) {
2371                         print_debug(" failed\r\n");
2372                         continue;
2373                 }
2374
2375                 if (!is_cpu_pre_c0()) {
2376                         /* Wait until it is safe to touch memory */
2377                         dcl &= ~(DCL_MemClrStatus | DCL_DramEnable);
2378                         pci_write_config32(ctrl[i].f2, DRAM_CONFIG_LOW, dcl);
2379                         do {
2380                                 dcl = pci_read_config32(ctrl[i].f2, DRAM_CONFIG_LOW);
2381                         } while(((dcl & DCL_MemClrStatus) == 0) || ((dcl & DCL_DramEnable) == 0) );
2382                 }
2383
2384                 print_debug(" done\r\n");
2385         }
2386
2387 #if K8_HW_MEM_HOLE_SIZEK != 0
2388          // init hw mem hole here
2389         /* DramHoleValid bit only can be set after MemClrStatus is set by Hardware */
2390         if(!is_cpu_pre_e0())
2391                 set_hw_mem_hole(controllers, ctrl);
2392 #endif
2393
2394         //FIXME add enable node interleaving here -- yhlu
2395         /*needed?
2396                 1. check how many nodes we have , if not all has ram installed get out
2397                 2. check cs_base lo is 0, node 0 f2 0x40,,,,, if any one is not using lo is CS_BASE, get out
2398                 3. check if other node is the same as node 0 about f2 0x40,,,,, otherwise get out
2399                 4. if all ready enable node_interleaving in f1 0x40..... of every node
2400                 5. for node interleaving we need to set mem hole to every node ( need recalcute hole offset in f0 for every node)
2401         */
2402
2403 #if USE_DCACHE_RAM == 0
2404         /* Make certain the first 1M of memory is intialized */
2405         print_debug("Clearing initial memory region: ");
2406
2407         /* Use write combine caching while we setup the  first 1M */
2408         cache_lbmem(MTRR_TYPE_WRCOMB);
2409
2410         /* clear memory 1meg */
2411         clear_memory((void *)0, CONFIG_LB_MEM_TOPK << 10);
2412
2413         /* The first 1M is now setup, use it */
2414         cache_lbmem(MTRR_TYPE_WRBACK);
2415
2416         print_debug(" done\r\n");
2417 #endif
2418 }
2419
2420 static int mem_inited(int controllers, const struct mem_controller *ctrl)
2421 {
2422         int i;
2423
2424         unsigned mask = 0;
2425         unsigned mask_inited = 0;
2426
2427         for(i = 0; i < controllers; i++) {
2428                 uint32_t dcl;
2429                 if (!controller_present(ctrl + i))
2430                         continue;
2431
2432                 mask |= (1<<i);
2433                 dcl = pci_read_config32(ctrl[i].f2, DRAM_CONFIG_LOW);
2434
2435                 if (!is_cpu_pre_c0()) { // B3
2436
2437                         if(  (dcl & DCL_MemClrStatus)  && (dcl & DCL_DramEnable) ) {
2438                                 mask_inited |= (1<<i);
2439                         }
2440                 }
2441         }
2442
2443         if(mask == mask_inited) return 1;
2444
2445         return 0;
2446
2447 }
2448 #if USE_DCACHE_RAM == 1
2449 static void fill_mem_ctrl(int controllers, struct mem_controller *ctrl_a, const uint16_t *spd_addr)
2450 {
2451         int i;
2452         int j;
2453         struct mem_controller *ctrl;
2454         for(i=0;i<controllers; i++) {
2455                 ctrl = &ctrl_a[i];
2456                 ctrl->node_id = i;
2457                 ctrl->f0 = PCI_DEV(0, 0x18+i, 0);
2458                 ctrl->f1 = PCI_DEV(0, 0x18+i, 1);
2459                 ctrl->f2 = PCI_DEV(0, 0x18+i, 2);
2460                 ctrl->f3 = PCI_DEV(0, 0x18+i, 3);
2461
2462                 if(spd_addr == (void *)0) continue;
2463
2464                 for(j=0;j<DIMM_SOCKETS;j++) {
2465                         ctrl->channel0[j] = spd_addr[(i*2+0)*DIMM_SOCKETS + j];
2466                         ctrl->channel1[j] = spd_addr[(i*2+1)*DIMM_SOCKETS + j];
2467                 }
2468         }
2469 }
2470 #endif