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