src/northbridge/intel/i440bx/raminit.c

   1 /*
   2  * This file is part of the LinuxBIOS project.
   3  *
   4  * Copyright (C) 2007 Uwe Hermann <uwe@hermann-uwe.de>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  19  */
  20
  21 #include <spd.h>
  22 #include <sdram_mode.h>
  23 #include <delay.h>
  24 #include "i440bx.h"
  25
  26 /*-----------------------------------------------------------------------------
  27 Macros and definitions.
  28 -----------------------------------------------------------------------------*/
  29
  30 /* Uncomment this to enable debugging output. */
  31 #define DEBUG_RAM_SETUP 1
  32
  33 /* Debugging macros. */
  34 #if defined(DEBUG_RAM_SETUP)
  35 #define PRINT_DEBUG(x)          print_debug(x)
  36 #define PRINT_DEBUG_HEX8(x)     print_debug_hex8(x)
  37 #define PRINT_DEBUG_HEX16(x)    print_debug_hex16(x)
  38 #define PRINT_DEBUG_HEX32(x)    print_debug_hex32(x)
  39 #define DUMPNORTH()             dump_pci_device(PCI_DEV(0, 0, 0))
  40 #else
  41 #define PRINT_DEBUG(x)
  42 #define PRINT_DEBUG_HEX8(x)
  43 #define PRINT_DEBUG_HEX16(x)
  44 #define PRINT_DEBUG_HEX32(x)
  45 #define DUMPNORTH()
  46 #endif
  47
  48 /* SDRAMC[7:5] - SDRAM Mode Select (SMS). */
  49 #define RAM_COMMAND_NORMAL      0x0
  50 #define RAM_COMMAND_NOP         0x1
  51 #define RAM_COMMAND_PRECHARGE   0x2
  52 #define RAM_COMMAND_MRS         0x3
  53 #define RAM_COMMAND_CBR         0x4
  54
  55 /* Map the JEDEC SPD refresh rates (array index) to 440BX refresh rates as
  56  * defined in DRAMC[2:0].
  57  *
  58  * [0] == Normal        15.625 us ->  15.6 us
  59  * [1] == Reduced(.25X)    3.9 us ->   7.8 ns
  60  * [2] == Reduced(.5X)     7.8 us ->   7.8 us
  61  * [3] == Extended(2x)    31.3 us ->  31.2 us
  62  * [4] == Extended(4x)    62.5 us ->  62.4 us
  63  * [5] == Extended(8x)     125 us -> 124.8 us
  64  */
  65 static const uint32_t refresh_rate_map[] = {
  66         1, 5, 5, 2, 3, 4
  67 };
  68
  69 /* Table format: register, bitmask, value. */
  70 static const long register_values[] = {
  71         /* NBXCFG - NBX Configuration Register
  72          * 0x50 - 0x53
  73          *
  74          * [31:24] SDRAM Row Without ECC
  75          *         0 = ECC components are populated in this row
  76          *         1 = ECC components are not populated in this row
  77          * [23:19] Reserved
  78          * [18:18] Host Bus Fast Data Ready Enable (HBFDRE)
  79          *         Assertion of DRAM data on host bus occurs...
  80          *         0 = ...one clock after sampling snoop results (default)
  81          *         1 = ...on the same clock the snoop result is being sampled
  82          *             (this mode is faster by one clock cycle)
  83          * [17:17] ECC - EDO static Drive mode
  84          *         0 = Normal mode (default)
  85          *         1 = ECC signals are always driven
  86          * [16:16] IDSEL_REDIRECT
  87          *         0 = IDSEL1 is allocated to this bridge (default)
  88          *         1 = IDSEL7 is allocated to this bridge
  89          * [15:15] WSC# Handshake Disable
  90          *         1 = Uni-processor mode
  91          *         0 = Dual-processor mode with external IOAPIC (default)
  92          * [14:14] Intel Reserved
  93          * [13:12] Host/DRAM Frequency
  94          *         00 = 100 MHz
  95          *         01 = Reserved
  96          *         10 = 66 MHz
  97          *         11 = Reserved
  98          * [11:11] AGP to PCI Access Enable
  99          *         1 = Enable
 100          *         0 = Disable
 101          * [10:10] PCI Agent to Aperture Access Disable
 102          *         1 = Disable
 103          *         0 = Enable (default)
 104          * [09:09] Aperture Access Global Enable
 105          *         1 = Enable
 106          *         0 = Disable
 107          * [08:07] DRAM Data Integrity Mode (DDIM)
 108          *         00 = Non-ECC
 109          *         01 = EC-only
 110          *         10 = ECC Mode
 111          *         11 = ECC Mode with hardware scrubbing enabled
 112          * [06:06] ECC Diagnostic Mode Enable (EDME)
 113          *         1 = Enable
 114          *         0 = Normal operation mode (default)
 115          * [05:05] MDA Present (MDAP)
 116          *         Works in conjunction with the VGA_EN bit.
 117          *         VGA_EN MDAP
 118          *           0     x   All VGA cycles are sent to PCI
 119          *           1     0   All VGA cycles are sent to AGP
 120          *           1     1   All VGA cycles are sent to AGP, except for
 121          *                     cycles in the MDA range.
 122          * [04:04] Reserved
 123          * [03:03] USWC Write Post During I/O Bridge Access Enable (UWPIO)
 124          *         1 = Enable
 125          *         0 = Disable
 126          * [02:02] In-Order Queue Depth (IOQD)
 127          *         1 = In-order queue = maximum
 128          *         0 = A7# is sampled asserted (i.e., 0)
 129          * [01:00] Reserved
 130          */
 131         // TODO
 132         NBXCFG + 0, 0x00, 0x0c,
 133         // NBXCFG + 1, 0x00, 0xa0,
 134         NBXCFG + 1, 0x00, 0x80,
 135         NBXCFG + 2, 0x00, 0x00,
 136         NBXCFG + 3, 0x00, 0xff,
 137
 138         /* DRAMC - DRAM Control Register
 139          * 0x57
 140          *
 141          * [7:6] Reserved
 142          * [5:5] Module Mode Configuration (MMCONFIG)
 143          *       TODO
 144          * [4:3] DRAM Type (DT)
 145          *       00 = EDO
 146          *       01 = SDRAM
 147          *       10 = Registered SDRAM
 148          *       11 = Reserved
 149          *       Note: EDO, SDRAM and Registered SDRAM cannot be mixed.
 150          * [2:0] DRAM Refresh Rate (DRR)
 151          *       000 = Refresh disabled
 152          *       001 = 15.6 us
 153          *       010 = 31.2 us
 154          *       011 = 62.4 us
 155          *       100 = 124.8 us
 156          *       101 = 249.6 us
 157          *       110 = Reserved
 158          *       111 = Reserved
 159          */
 160         /* Choose SDRAM (not registered), and disable refresh for now. */
 161         DRAMC, 0x00, 0x08,
 162
 163         /*
 164          * PAM[6:0] - Programmable Attribute Map Registers
 165          * 0x59 - 0x5f
 166          *
 167          * 0x59 [3:0] Reserved
 168          * 0x59 [5:4] 0xF0000 - 0xFFFFF BIOS area
 169          * 0x5a [1:0] 0xC0000 - 0xC3FFF ISA add-on BIOS
 170          * 0x5a [5:4] 0xC4000 - 0xC7FFF ISA add-on BIOS
 171          * 0x5b [1:0] 0xC8000 - 0xCBFFF ISA add-on BIOS
 172          * 0x5b [5:4] 0xCC000 - 0xCFFFF ISA add-on BIOS
 173          * 0x5c [1:0] 0xD0000 - 0xD3FFF ISA add-on BIOS
 174          * 0x5c [5:4] 0xD4000 - 0xD7FFF ISA add-on BIOS
 175          * 0x5d [1:0] 0xD8000 - 0xDBFFF ISA add-on BIOS
 176          * 0x5d [5:4] 0xDC000 - 0xDFFFF ISA add-on BIOS
 177          * 0x5e [1:0] 0xE0000 - 0xE3FFF BIOS entension
 178          * 0x5e [5:4] 0xE4000 - 0xE7FFF BIOS entension
 179          * 0x5f [1:0] 0xE8000 - 0xEBFFF BIOS entension
 180          * 0x5f [5:4] 0xEC000 - 0xEFFFF BIOS entension
 181          *
 182          * Bit assignment:
 183          * 00 = DRAM Disabled (all access goes to memory mapped I/O space)
 184          * 01 = Read Only (Reads to DRAM, writes to memory mapped I/O space)
 185          * 10 = Write Only (Writes to DRAM, reads to memory mapped I/O space)
 186          * 11 = Read/Write (all access goes to DRAM)
 187          */
 188         // TODO
 189         PAM0, 0x00, 0x00,
 190         PAM1, 0x00, 0x00,
 191         PAM2, 0x00, 0x00,
 192         PAM3, 0x00, 0x00,
 193         PAM4, 0x00, 0x00,
 194         PAM5, 0x00, 0x00,
 195         PAM6, 0x00, 0x00,
 196
 197         /* DRB[0:7] - DRAM Row Boundary Registers
 198          * 0x60 - 0x67
 199          *
 200          * An array of 8 byte registers, which hold the ending memory address
 201          * assigned to each pair of DIMMs, in 8MB granularity.
 202          *
 203          * 0x60 DRB0 = Total memory in row0 (in 8 MB)
 204          * 0x61 DRB1 = Total memory in row0+1 (in 8 MB)
 205          * 0x62 DRB2 = Total memory in row0+1+2 (in 8 MB)
 206          * 0x63 DRB3 = Total memory in row0+1+2+3 (in 8 MB)
 207          * 0x64 DRB4 = Total memory in row0+1+2+3+4 (in 8 MB)
 208          * 0x65 DRB5 = Total memory in row0+1+2+3+4+5 (in 8 MB)
 209          * 0x66 DRB6 = Total memory in row0+1+2+3+4+5+6 (in 8 MB)
 210          * 0x67 DRB7 = Total memory in row0+1+2+3+4+5+6+7 (in 8 MB)
 211          */
 212         /* Set the DRBs to zero for now, this will be fixed later. */
 213         DRB0, 0x00, 0x00,
 214         DRB1, 0x00, 0x00,
 215         DRB2, 0x00, 0x00,
 216         DRB3, 0x00, 0x00,
 217         DRB4, 0x00, 0x00,
 218         DRB5, 0x00, 0x00,
 219         DRB6, 0x00, 0x00,
 220         DRB7, 0x00, 0x00,
 221
 222         /* FDHC - Fixed DRAM Hole Control Register
 223          * 0x68
 224          *
 225          * Controls two fixed DRAM holes: 512 KB - 640 KB and 15 MB - 16 MB.
 226          *
 227          * [7:6] Hole Enable (HEN)
 228          *       00 = None
 229          *       01 = 512 KB - 640 KB (128 KB)
 230          *       10 = 15 MB - 16 MB (1 MB)
 231          *       11 = Reserved
 232          * [5:0] Reserved
 233          */
 234         /* No memory holes. */
 235         FDHC, 0x00, 0x00,
 236
 237         /* RPS - SDRAM Row Page Size Register
 238          * 0x74 - 0x75
 239          *
 240          * Sets the row page size for SDRAM. For EDO memory, the page
 241          * size is fixed at 2 KB.
 242          *
 243          * [15:0] Page Size (PS)
 244          *        TODO
 245          */
 246         // TODO
 247         RPS + 0, 0x00, 0x00,
 248         RPS + 1, 0x00, 0x00,
 249
 250         /* SDRAMC - SDRAM Control Register
 251          * 0x76 - 0x77
 252          *
 253          * [15:10] Reserved
 254          * [09:08] Idle/Pipeline DRAM Leadoff Timing (IPDLT)
 255          *         00 = Illegal
 256          *         01 = Add a clock delay to the lead-off clock count
 257          *         10 = Illegal
 258          *         11 = Illegal
 259          * [07:05] SDRAM Mode Select (SMS)
 260          *         000 = Normal SDRAM Operation (default)
 261          *         001 = NOP Command Enable
 262          *         010 = All Banks Precharge Enable
 263          *         011 = Mode Register Set Enable
 264          *         100 = CBR Enable
 265          *         101 = Reserved
 266          *         110 = Reserved
 267          *         111 = Reserved
 268          * [04:04] SDRAMPWR
 269          *         0 = 3 DIMM configuration
 270          *         1 = 4 DIMM configuration
 271          * [03:03] Leadoff Command Timing (LCT)
 272          *         0 = 4 CS# Clock
 273          *         1 = 3 CS# Clock
 274          * [02:02] CAS# Latency (CL)
 275          *         0 = 3 DCLK CAS# latency
 276          *         1 = 2 DCLK CAS# latency
 277          * [01:01] SDRAM RAS# to CAS# Delay (SRCD)
 278          *         0 = 3 clocks between a row activate and a read or write cmd.
 279          *         1 = 2 clocks between a row activate and a read or write cmd.
 280          * [00:00] SDRAM RAS# Precharge (SRP)
 281          *         0 = 3 clocks of RAS# precharge
 282          *         1 = 2 clocks of RAS# precharge
 283          */
 284         SDRAMC + 0, 0x00, 0x00,
 285         SDRAMC + 0, 0x00, 0x00,
 286
 287         /* PGPOL - Paging Policy Register
 288          * 0x78 - 0x79
 289          *
 290          * [15:08] Banks per Row (BPR)
 291          *         TODO
 292          *         0 = 2 banks
 293          *         1 = 4 banks
 294          * [07:05] Reserved
 295          * [04:04] Intel Reserved
 296          * [03:00] DRAM Idle Timer (DIT)
 297          *         0000 = 0 clocks
 298          *         0001 = 2 clocks
 299          *         0010 = 4 clocks
 300          *         0011 = 8 clocks
 301          *         0100 = 10 clocks
 302          *         0101 = 12 clocks
 303          *         0110 = 16 clocks
 304          *         0111 = 32 clocks
 305          *         1xxx = Infinite (pages are not closed for idle condition)
 306          */
 307         // TODO
 308         PGPOL + 0, 0x00, 0x00,
 309         PGPOL + 1, 0x00, 0xff,
 310
 311         /* PMCR - Power Management Control Register
 312          * 0x7a
 313          *
 314          * [07:07] Power Down SDRAM Enable (PDSE)
 315          *         1 = Enable
 316          *         0 = Disable
 317          * [06:06] ACPI Control Register Enable (SCRE)
 318          *         1 = Enable
 319          *         0 = Disable (default)
 320          * [05:05] Suspend Refresh Type (SRT)
 321          *         1 = Self refresh mode
 322          *         0 = CBR fresh mode
 323          * [04:04] Normal Refresh Enable (NREF_EN)
 324          *         1 = Enable
 325          *         0 = Disable
 326          * [03:03] Quick Start Mode (QSTART)
 327          *         1 = Quick start mode for the processor is enabled
 328          * [02:02] Gated Clock Enable (GCLKEN)
 329          *         1 = Enable
 330          *         0 = Disable
 331          * [01:01] AGP Disable (AGP_DIS)
 332          *         1 = Disable
 333          *         0 = Enable
 334          * [00:00] CPU reset without PCIRST enable (CRst_En)
 335          *         1 = Enable
 336          *         0 = Disable
 337          */
 338         /* Enable normal refresh and the gated clock. */
 339         // TODO: Only do this later?
 340         // PMCR, 0x00, 0x14,
 341         // PMCR, 0x00, 0x10,
 342         PMCR, 0x00, 0x00,
 343 };
 344
 345 /*-----------------------------------------------------------------------------
 346 SDRAM configuration functions.
 347 -----------------------------------------------------------------------------*/
 348
 349 /**
 350  * Send the specified RAM command to all DIMMs.
 351  *
 352  * @param Memory controller
 353  * @param TODO
 354  * @param TODO
 355  */
 356 static void do_ram_command(const struct mem_controller *ctrl,
 357                            uint32_t command, uint32_t addr_offset)
 358 {
 359         int i;
 360         uint16_t reg;
 361
 362         /* TODO: Support for multiple DIMMs. */
 363
 364         /* Configure the RAM command. */
 365         reg = pci_read_config16(ctrl->d0, SDRAMC);
 366         reg &= 0xff1f;          /* Clear bits 7-5. */
 367         reg |= (uint16_t) (command << 5);
 368         pci_write_config16(ctrl->d0, SDRAMC, reg);
 369
 370         /* RAM_COMMAND_NORMAL affects only the memory controller and
 371            doesn't need to be "sent" to the DIMMs. */
 372         /* if (command == RAM_COMMAND_NORMAL) return; */
 373
 374         PRINT_DEBUG("    Sending RAM command 0x");
 375         PRINT_DEBUG_HEX16(reg);
 376         PRINT_DEBUG(" to 0x");
 377         PRINT_DEBUG_HEX32(0 + addr_offset); // FIXME
 378         PRINT_DEBUG("\r\n");
 379
 380         /* Read from (DIMM start address + addr_offset). */
 381         read32(0 + addr_offset); // FIXME
 382 }
 383
 384 /*-----------------------------------------------------------------------------
 385 DIMM-independant configuration functions.
 386 -----------------------------------------------------------------------------*/
 387
 388 /**
 389  * TODO.
 390  *
 391  * @param Memory controller
 392  */
 393 static void spd_enable_refresh(const struct mem_controller *ctrl)
 394 {
 395         int i, value;
 396         uint8_t reg;
 397
 398         reg = pci_read_config8(ctrl->d0, DRAMC);
 399
 400         for (i = 0; i < DIMM_SOCKETS; i++) {
 401                 value = spd_read_byte(ctrl->channel0[i], SPD_REFRESH);
 402                 if (value < 0)
 403                         continue;
 404                 reg = (reg & 0xf8) | refresh_rate_map[(value & 0x7f)];
 405
 406                 PRINT_DEBUG("    Enabling refresh (DRAMC = 0x");
 407                 PRINT_DEBUG_HEX8(reg);
 408                 PRINT_DEBUG(") for DIMM ");
 409                 PRINT_DEBUG_HEX8(i);
 410                 PRINT_DEBUG("\r\n");
 411         }
 412
 413         pci_write_config8(ctrl->d0, DRAMC, reg);
 414 }
 415
 416 /*-----------------------------------------------------------------------------
 417 Public interface.
 418 -----------------------------------------------------------------------------*/
 419
 420 /**
 421  * TODO.
 422  *
 423  * @param Memory controller
 424  */
 425 static void sdram_set_registers(const struct mem_controller *ctrl)
 426 {
 427         int i, max;
 428         uint8_t reg;
 429
 430         PRINT_DEBUG("Northbridge prior to SDRAM init:\r\n");
 431         DUMPNORTH();
 432
 433         max = sizeof(register_values) / sizeof(register_values[0]);
 434
 435         /* Set registers as specified in the register_values[] array. */
 436         for (i = 0; i < max; i += 3) {
 437                 reg = pci_read_config8(ctrl->d0, register_values[i]);
 438                 reg &= register_values[i + 1];
 439                 reg |= register_values[i + 2] & ~(register_values[i + 1]);
 440                 pci_write_config8(ctrl->d0, register_values[i], reg);
 441
 442                 PRINT_DEBUG("    Set register 0x");
 443                 PRINT_DEBUG_HEX8(register_values[i]);
 444                 PRINT_DEBUG(" to 0x");
 445                 PRINT_DEBUG_HEX8(reg);
 446                 PRINT_DEBUG("\r\n");
 447         }
 448 }
 449
 450 /**
 451  * TODO.
 452  *
 453  * @param Memory controller
 454  */
 455 static void sdram_set_spd_registers(const struct mem_controller *ctrl)
 456 {
 457         /* TODO: Don't hardcode the values here, get info via SPD. */
 458
 459         /* Map all legacy regions to RAM (read/write). This is required if
 460          * you want to use the RAM area from 768 KB - 1 MB. If the PAM
 461          * registers are not set here appropriately, the RAM in that region
 462          * will not be accessible, thus a RAM check of it will also fail.
 463          */
 464         pci_write_config8(ctrl->d0, PAM0, 0x30);
 465         pci_write_config8(ctrl->d0, PAM1, 0x33);
 466         pci_write_config8(ctrl->d0, PAM2, 0x33);
 467         pci_write_config8(ctrl->d0, PAM3, 0x33);
 468         pci_write_config8(ctrl->d0, PAM4, 0x33);
 469         pci_write_config8(ctrl->d0, PAM5, 0x33);
 470         pci_write_config8(ctrl->d0, PAM6, 0x33);
 471
 472         /* TODO: Set DRB0-DRB7. */
 473         /* Currently this is hardcoded to one 64 MB DIMM in slot 0. */
 474         pci_write_config8(ctrl->d0, DRB0, 0x08);
 475         pci_write_config8(ctrl->d0, DRB1, 0x08);
 476         pci_write_config8(ctrl->d0, DRB2, 0x08);
 477         pci_write_config8(ctrl->d0, DRB3, 0x08);
 478         pci_write_config8(ctrl->d0, DRB4, 0x08);
 479         pci_write_config8(ctrl->d0, DRB5, 0x08);
 480         pci_write_config8(ctrl->d0, DRB6, 0x08);
 481         pci_write_config8(ctrl->d0, DRB7, 0x08);
 482
 483         /* TODO: Set DRAMC. Don't enable refresh for now. */
 484         pci_write_config8(ctrl->d0, DRAMC, 0x08);
 485
 486         /* TODO: Set RPS. */
 487         pci_write_config16(ctrl->d0, RPS, 0x0001);
 488
 489         /* TODO: Set SDRAMC. */
 490         // pci_write_config16(ctrl->d0, SDRAMC, 0x010f); // FIXME?
 491         pci_write_config16(ctrl->d0, SDRAMC, 0x0003); // FIXME?
 492
 493         /* TODO: Set PGPOL. */
 494         // pci_write_config16(ctrl->d0, PGPOL, 0x0107);
 495         pci_write_config16(ctrl->d0, PGPOL, 0x0123);
 496
 497         /* TODO: Set NBXCFG. */
 498         // pci_write_config32(ctrl->d0, NBXCFG, 0x0100220c); // FIXME?
 499         pci_write_config32(ctrl->d0, NBXCFG, 0xff00800c);
 500
 501         /* TODO: Set PMCR? */
 502         // pci_write_config8(ctrl->d0, PMCR, 0x14);
 503         pci_write_config8(ctrl->d0, PMCR, 0x10);
 504
 505         /* TODO? */
 506         pci_write_config8(ctrl->d0, PCI_LATENCY_TIMER, 0x40);
 507         pci_write_config8(ctrl->d0, DRAMT, 0x03);
 508         pci_write_config8(ctrl->d0, MBSC, 0x03);
 509         pci_write_config8(ctrl->d0, SCRR, 0x38);
 510 }
 511
 512 /**
 513  * Enable SDRAM.
 514  *
 515  * @param Number of controllers
 516  * @param Memory controller
 517  */
 518 static void sdram_enable(int controllers, const struct mem_controller *ctrl)
 519 {
 520         int i;
 521
 522         /* 0. Wait until power/voltages and clocks are stable (200us). */
 523         udelay(200);
 524
 525         /* 1. Apply NOP. Wait 200 clock cycles (200us should do). */
 526         PRINT_DEBUG("RAM Enable 1: Apply NOP\r\n");
 527         do_ram_command(ctrl, RAM_COMMAND_NOP, 0);
 528         udelay(200);
 529
 530         /* 2. Precharge all. Wait tRP. */
 531         PRINT_DEBUG("RAM Enable 2: Precharge all\r\n");
 532         do_ram_command(ctrl, RAM_COMMAND_PRECHARGE, 0);
 533         udelay(1);
 534
 535         /* 3. Perform 8 refresh cycles. Wait tRC each time. */
 536         PRINT_DEBUG("RAM Enable 3: CBR\r\n");
 537         for (i = 0; i < 8; i++) {
 538                 do_ram_command(ctrl, RAM_COMMAND_CBR, 0);
 539                 udelay(1);
 540         }
 541
 542         /* 4. Mode register set. Wait two memory cycles. */
 543         PRINT_DEBUG("RAM Enable 4: Mode register set\r\n");
 544         do_ram_command(ctrl, RAM_COMMAND_MRS, 0x1d0);
 545         udelay(2);
 546
 547         /* 5. Normal operation. */
 548         PRINT_DEBUG("RAM Enable 5: Normal operation\r\n");
 549         do_ram_command(ctrl, RAM_COMMAND_NORMAL, 0);
 550         udelay(1);
 551
 552         /* 6. Finally enable refresh. */
 553         PRINT_DEBUG("RAM Enable 6: Enable refresh\r\n");
 554         // pci_write_config8(ctrl->d0, PMCR, 0x10);
 555         spd_enable_refresh(ctrl);
 556         udelay(1);
 557
 558         PRINT_DEBUG("Northbridge following SDRAM init:\r\n");
 559         DUMPNORTH();
 560 }