src/northbridge/amd/amdk8/raminit.c

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