arch/ppc/cpu/ppc4xx/denali_spd_ddr2.c

   1 /*
   2  * arch/ppc/cpu/ppc4xx/denali_spd_ddr2.c
   3  * This SPD SDRAM detection code supports AMCC PPC44x CPUs with a Denali-core
   4  * DDR2 controller, specifically the 440EPx/GRx.
   5  *
   6  * (C) Copyright 2007-2008
   7  * Larry Johnson, lrj@acm.org.
   8  *
   9  * Based primarily on arch/ppc/cpu/ppc4xx/4xx_spd_ddr2.c, which is...
  10  *
  11  * (C) Copyright 2007
  12  * Stefan Roese, DENX Software Engineering, sr@denx.de.
  13  *
  14  * COPYRIGHT   AMCC   CORPORATION 2004
  15  *
  16  * See file CREDITS for list of people who contributed to this
  17  * project.
  18  *
  19  * This program is free software; you can redistribute it and/or
  20  * modify it under the terms of the GNU General Public License as
  21  * published by the Free Software Foundation; either version 2 of
  22  * the License, or (at your option) any later version.
  23  *
  24  * This program is distributed in the hope that it will be useful,
  25  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27  * GNU General Public License for more details.
  28  *
  29  * You should have received a copy of the GNU General Public License
  30  * along with this program; if not, write to the Free Software
  31  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  32  * MA 02111-1307 USA
  33  *
  34  */
  35
  36 /* define DEBUG for debugging output (obviously ;-)) */
  37 #if 0
  38 #define DEBUG
  39 #endif
  40
  41 #include <common.h>
  42 #include <command.h>
  43 #include <ppc4xx.h>
  44 #include <i2c.h>
  45 #include <asm/io.h>
  46 #include <asm/processor.h>
  47 #include <asm/mmu.h>
  48 #include <asm/cache.h>
  49
  50 #if defined(CONFIG_SPD_EEPROM) &&                               \
  51         (defined(CONFIG_440EPX) || defined(CONFIG_440GRX))
  52
  53 /*-----------------------------------------------------------------------------+
  54  * Defines
  55  *-----------------------------------------------------------------------------*/
  56 #ifndef TRUE
  57 #define TRUE            1
  58 #endif
  59 #ifndef FALSE
  60 #define FALSE           0
  61 #endif
  62
  63 #define MAXDIMMS        2
  64 #define MAXRANKS        2
  65
  66 #define ONE_BILLION     1000000000
  67
  68 #define MULDIV64(m1, m2, d)     (u32)(((u64)(m1) * (u64)(m2)) / (u64)(d))
  69
  70 #define DLL_DQS_DELAY   0x19
  71 #define DLL_DQS_BYPASS  0x0B
  72 #define DQS_OUT_SHIFT   0x7F
  73
  74 /*
  75  * This DDR2 setup code can dynamically setup the TLB entries for the DDR2 memory
  76  * region. Right now the cache should still be disabled in U-Boot because of the
  77  * EMAC driver, that need it's buffer descriptor to be located in non cached
  78  * memory.
  79  *
  80  * If at some time this restriction doesn't apply anymore, just define
  81  * CONFIG_4xx_DCACHE in the board config file and this code should setup
  82  * everything correctly.
  83  */
  84 #if defined(CONFIG_4xx_DCACHE)
  85 #define MY_TLB_WORD2_I_ENABLE   0                       /* enable caching on SDRAM */
  86 #else
  87 #define MY_TLB_WORD2_I_ENABLE   TLB_WORD2_I_ENABLE      /* disable caching on SDRAM */
  88 #endif
  89
  90 /*-----------------------------------------------------------------------------+
  91  * Prototypes
  92  *-----------------------------------------------------------------------------*/
  93 extern int denali_wait_for_dlllock(void);
  94 extern void denali_core_search_data_eye(void);
  95 extern void dcbz_area(u32 start_address, u32 num_bytes);
  96
  97 /*
  98  * Board-specific Platform code can reimplement spd_ddr_init_hang () if needed
  99  */
 100 void __spd_ddr_init_hang(void)
 101 {
 102         hang();
 103 }
 104 void spd_ddr_init_hang(void)
 105     __attribute__ ((weak, alias("__spd_ddr_init_hang")));
 106
 107 #if defined(DEBUG)
 108 static void print_mcsr(void)
 109 {
 110         printf("MCSR = 0x%08X\n", mfspr(SPRN_MCSR));
 111 }
 112
 113 static void denali_sdram_register_dump(void)
 114 {
 115         unsigned int sdram_data;
 116
 117         printf("\n  Register Dump:\n");
 118         mfsdram(DDR0_00, sdram_data);
 119         printf("        DDR0_00 = 0x%08X", sdram_data);
 120         mfsdram(DDR0_01, sdram_data);
 121         printf("        DDR0_01 = 0x%08X\n", sdram_data);
 122         mfsdram(DDR0_02, sdram_data);
 123         printf("        DDR0_02 = 0x%08X", sdram_data);
 124         mfsdram(DDR0_03, sdram_data);
 125         printf("        DDR0_03 = 0x%08X\n", sdram_data);
 126         mfsdram(DDR0_04, sdram_data);
 127         printf("        DDR0_04 = 0x%08X", sdram_data);
 128         mfsdram(DDR0_05, sdram_data);
 129         printf("        DDR0_05 = 0x%08X\n", sdram_data);
 130         mfsdram(DDR0_06, sdram_data);
 131         printf("        DDR0_06 = 0x%08X", sdram_data);
 132         mfsdram(DDR0_07, sdram_data);
 133         printf("        DDR0_07 = 0x%08X\n", sdram_data);
 134         mfsdram(DDR0_08, sdram_data);
 135         printf("        DDR0_08 = 0x%08X", sdram_data);
 136         mfsdram(DDR0_09, sdram_data);
 137         printf("        DDR0_09 = 0x%08X\n", sdram_data);
 138         mfsdram(DDR0_10, sdram_data);
 139         printf("        DDR0_10 = 0x%08X", sdram_data);
 140         mfsdram(DDR0_11, sdram_data);
 141         printf("        DDR0_11 = 0x%08X\n", sdram_data);
 142         mfsdram(DDR0_12, sdram_data);
 143         printf("        DDR0_12 = 0x%08X", sdram_data);
 144         mfsdram(DDR0_14, sdram_data);
 145         printf("        DDR0_14 = 0x%08X\n", sdram_data);
 146         mfsdram(DDR0_17, sdram_data);
 147         printf("        DDR0_17 = 0x%08X", sdram_data);
 148         mfsdram(DDR0_18, sdram_data);
 149         printf("        DDR0_18 = 0x%08X\n", sdram_data);
 150         mfsdram(DDR0_19, sdram_data);
 151         printf("        DDR0_19 = 0x%08X", sdram_data);
 152         mfsdram(DDR0_20, sdram_data);
 153         printf("        DDR0_20 = 0x%08X\n", sdram_data);
 154         mfsdram(DDR0_21, sdram_data);
 155         printf("        DDR0_21 = 0x%08X", sdram_data);
 156         mfsdram(DDR0_22, sdram_data);
 157         printf("        DDR0_22 = 0x%08X\n", sdram_data);
 158         mfsdram(DDR0_23, sdram_data);
 159         printf("        DDR0_23 = 0x%08X", sdram_data);
 160         mfsdram(DDR0_24, sdram_data);
 161         printf("        DDR0_24 = 0x%08X\n", sdram_data);
 162         mfsdram(DDR0_25, sdram_data);
 163         printf("        DDR0_25 = 0x%08X", sdram_data);
 164         mfsdram(DDR0_26, sdram_data);
 165         printf("        DDR0_26 = 0x%08X\n", sdram_data);
 166         mfsdram(DDR0_27, sdram_data);
 167         printf("        DDR0_27 = 0x%08X", sdram_data);
 168         mfsdram(DDR0_28, sdram_data);
 169         printf("        DDR0_28 = 0x%08X\n", sdram_data);
 170         mfsdram(DDR0_31, sdram_data);
 171         printf("        DDR0_31 = 0x%08X", sdram_data);
 172         mfsdram(DDR0_32, sdram_data);
 173         printf("        DDR0_32 = 0x%08X\n", sdram_data);
 174         mfsdram(DDR0_33, sdram_data);
 175         printf("        DDR0_33 = 0x%08X", sdram_data);
 176         mfsdram(DDR0_34, sdram_data);
 177         printf("        DDR0_34 = 0x%08X\n", sdram_data);
 178         mfsdram(DDR0_35, sdram_data);
 179         printf("        DDR0_35 = 0x%08X", sdram_data);
 180         mfsdram(DDR0_36, sdram_data);
 181         printf("        DDR0_36 = 0x%08X\n", sdram_data);
 182         mfsdram(DDR0_37, sdram_data);
 183         printf("        DDR0_37 = 0x%08X", sdram_data);
 184         mfsdram(DDR0_38, sdram_data);
 185         printf("        DDR0_38 = 0x%08X\n", sdram_data);
 186         mfsdram(DDR0_39, sdram_data);
 187         printf("        DDR0_39 = 0x%08X", sdram_data);
 188         mfsdram(DDR0_40, sdram_data);
 189         printf("        DDR0_40 = 0x%08X\n", sdram_data);
 190         mfsdram(DDR0_41, sdram_data);
 191         printf("        DDR0_41 = 0x%08X", sdram_data);
 192         mfsdram(DDR0_42, sdram_data);
 193         printf("        DDR0_42 = 0x%08X\n", sdram_data);
 194         mfsdram(DDR0_43, sdram_data);
 195         printf("        DDR0_43 = 0x%08X", sdram_data);
 196         mfsdram(DDR0_44, sdram_data);
 197         printf("        DDR0_44 = 0x%08X\n", sdram_data);
 198 }
 199 #else
 200 static inline void denali_sdram_register_dump(void)
 201 {
 202 }
 203
 204 inline static void print_mcsr(void)
 205 {
 206 }
 207 #endif /* defined(DEBUG) */
 208
 209 static int is_ecc_enabled(void)
 210 {
 211         u32 val;
 212
 213         mfsdram(DDR0_22, val);
 214         return 0x3 == DDR0_22_CTRL_RAW_DECODE(val);
 215 }
 216
 217 static unsigned char spd_read(u8 chip, unsigned int addr)
 218 {
 219         u8 data[2];
 220
 221         if (0 != i2c_probe(chip) || 0 != i2c_read(chip, addr, 1, data, 1)) {
 222                 debug("spd_read(0x%02X, 0x%02X) failed\n", chip, addr);
 223                 return 0;
 224         }
 225         debug("spd_read(0x%02X, 0x%02X) returned 0x%02X\n",
 226               chip, addr, data[0]);
 227         return data[0];
 228 }
 229
 230 static unsigned long get_tcyc(unsigned char reg)
 231 {
 232         /*
 233          * Byte 9, et al: Cycle time for CAS Latency=X, is split into two
 234          * nibbles: the higher order nibble (bits 4-7) designates the cycle time
 235          * to a granularity of 1ns; the value presented by the lower order
 236          * nibble (bits 0-3) has a granularity of .1ns and is added to the value
 237          * designated by the higher nibble. In addition, four lines of the lower
 238          * order nibble are assigned to support +.25, +.33, +.66, and +.75.
 239          */
 240
 241         unsigned char subfield_b = reg & 0x0F;
 242
 243         switch (subfield_b & 0x0F) {
 244         case 0x0:
 245         case 0x1:
 246         case 0x2:
 247         case 0x3:
 248         case 0x4:
 249         case 0x5:
 250         case 0x6:
 251         case 0x7:
 252         case 0x8:
 253         case 0x9:
 254                 return 1000 * (reg >> 4) + 100 * subfield_b;
 255         case 0xA:
 256                 return 1000 * (reg >> 4) + 250;
 257         case 0xB:
 258                 return 1000 * (reg >> 4) + 333;
 259         case 0xC:
 260                 return 1000 * (reg >> 4) + 667;
 261         case 0xD:
 262                 return 1000 * (reg >> 4) + 750;
 263         }
 264         return 0;
 265 }
 266
 267 /*------------------------------------------------------------------
 268  * Find the installed DIMMs, make sure that the are DDR2, and fill
 269  * in the dimm_ranks array.  Then dimm_ranks[dimm_num] > 0 iff the
 270  * DIMM and dimm_num is present.
 271  * Note: Because there are only two chip-select lines, it is assumed
 272  * that a board with a single socket can support two ranks on that
 273  * socket, while a board with two sockets can support only one rank
 274  * on each socket.
 275  *-----------------------------------------------------------------*/
 276 static void get_spd_info(unsigned long dimm_ranks[],
 277                          unsigned long *ranks,
 278                          unsigned char const iic0_dimm_addr[],
 279                          unsigned long num_dimm_banks)
 280 {
 281         unsigned long dimm_num;
 282         unsigned long dimm_found = FALSE;
 283         unsigned long const max_ranks_per_dimm = (1 == num_dimm_banks) ? 2 : 1;
 284         unsigned char num_of_bytes;
 285         unsigned char total_size;
 286
 287         *ranks = 0;
 288         for (dimm_num = 0; dimm_num < num_dimm_banks; dimm_num++) {
 289                 num_of_bytes = 0;
 290                 total_size = 0;
 291
 292                 num_of_bytes = spd_read(iic0_dimm_addr[dimm_num], 0);
 293                 total_size = spd_read(iic0_dimm_addr[dimm_num], 1);
 294                 if ((num_of_bytes != 0) && (total_size != 0)) {
 295                         unsigned char const dimm_type =
 296                             spd_read(iic0_dimm_addr[dimm_num], 2);
 297
 298                         unsigned long ranks_on_dimm =
 299                             (spd_read(iic0_dimm_addr[dimm_num], 5) & 0x07) + 1;
 300
 301                         if (8 != dimm_type) {
 302                                 switch (dimm_type) {
 303                                 case 1:
 304                                         printf("ERROR: Standard Fast Page Mode "
 305                                                "DRAM DIMM");
 306                                         break;
 307                                 case 2:
 308                                         printf("ERROR: EDO DIMM");
 309                                         break;
 310                                 case 3:
 311                                         printf("ERROR: Pipelined Nibble DIMM");
 312                                         break;
 313                                 case 4:
 314                                         printf("ERROR: SDRAM DIMM");
 315                                         break;
 316                                 case 5:
 317                                         printf("ERROR: Multiplexed ROM DIMM");
 318                                         break;
 319                                 case 6:
 320                                         printf("ERROR: SGRAM DIMM");
 321                                         break;
 322                                 case 7:
 323                                         printf("ERROR: DDR1 DIMM");
 324                                         break;
 325                                 default:
 326                                         printf("ERROR: Unknown DIMM (type %d)",
 327                                                (unsigned int)dimm_type);
 328                                         break;
 329                                 }
 330                                 printf(" detected in slot %lu.\n", dimm_num);
 331                                 printf("Only DDR2 SDRAM DIMMs are supported."
 332                                        "\n");
 333                                 printf("Replace the module with a DDR2 DIMM."
 334                                        "\n\n");
 335                                 spd_ddr_init_hang();
 336                         }
 337                         dimm_found = TRUE;
 338                         debug("DIMM slot %lu: populated with %lu-rank DDR2 DIMM"
 339                               "\n", dimm_num, ranks_on_dimm);
 340                         if (ranks_on_dimm > max_ranks_per_dimm) {
 341                                 printf("WARNING: DRAM DIMM in slot %lu has %lu "
 342                                        "ranks.\n", dimm_num, ranks_on_dimm);
 343                                 if (1 == max_ranks_per_dimm) {
 344                                         printf("Only one rank will be used.\n");
 345                                 } else {
 346                                         printf
 347                                             ("Only two ranks will be used.\n");
 348                                 }
 349                                 ranks_on_dimm = max_ranks_per_dimm;
 350                         }
 351                         dimm_ranks[dimm_num] = ranks_on_dimm;
 352                         *ranks += ranks_on_dimm;
 353                 } else {
 354                         dimm_ranks[dimm_num] = 0;
 355                         debug("DIMM slot %lu: Not populated\n", dimm_num);
 356                 }
 357         }
 358         if (dimm_found == FALSE) {
 359                 printf("ERROR: No memory installed.\n");
 360                 printf("Install at least one DDR2 DIMM.\n\n");
 361                 spd_ddr_init_hang();
 362         }
 363         debug("Total number of ranks = %d\n", *ranks);
 364 }
 365
 366 /*------------------------------------------------------------------
 367  * For the memory DIMMs installed, this routine verifies that
 368  * frequency previously calculated is supported.
 369  *-----------------------------------------------------------------*/
 370 static void check_frequency(unsigned long *dimm_ranks,
 371                             unsigned char const iic0_dimm_addr[],
 372                             unsigned long num_dimm_banks,
 373                             unsigned long sdram_freq)
 374 {
 375         unsigned long dimm_num;
 376         unsigned long cycle_time;
 377         unsigned long calc_cycle_time;
 378
 379         /*
 380          * calc_cycle_time is calculated from DDR frequency set by board/chip
 381          * and is expressed in picoseconds to match the way DIMM cycle time is
 382          * calculated below.
 383          */
 384         calc_cycle_time = MULDIV64(ONE_BILLION, 1000, sdram_freq);
 385
 386         for (dimm_num = 0; dimm_num < num_dimm_banks; dimm_num++) {
 387                 if (dimm_ranks[dimm_num]) {
 388                         cycle_time =
 389                             get_tcyc(spd_read(iic0_dimm_addr[dimm_num], 9));
 390                         debug("cycle_time=%d ps\n", cycle_time);
 391
 392                         if (cycle_time > (calc_cycle_time + 10)) {
 393                                 /*
 394                                  * the provided sdram cycle_time is too small
 395                                  * for the available DIMM cycle_time. The
 396                                  * additionnal 10ps is here to accept a small
 397                                  * incertainty.
 398                                  */
 399                                 printf
 400                                     ("ERROR: DRAM DIMM detected with cycle_time %d ps in "
 401                                      "slot %d \n while calculated cycle time is %d ps.\n",
 402                                      (unsigned int)cycle_time,
 403                                      (unsigned int)dimm_num,
 404                                      (unsigned int)calc_cycle_time);
 405                                 printf
 406                                     ("Replace the DIMM, or change DDR frequency via "
 407                                      "strapping bits.\n\n");
 408                                 spd_ddr_init_hang();
 409                         }
 410                 }
 411         }
 412 }
 413
 414 /*------------------------------------------------------------------
 415  * This routine gets size information for the installed memory
 416  * DIMMs.
 417  *-----------------------------------------------------------------*/
 418 static void get_dimm_size(unsigned long dimm_ranks[],
 419                           unsigned char const iic0_dimm_addr[],
 420                           unsigned long num_dimm_banks,
 421                           unsigned long *const rows,
 422                           unsigned long *const banks,
 423                           unsigned long *const cols, unsigned long *const width)
 424 {
 425         unsigned long dimm_num;
 426
 427         *rows = 0;
 428         *banks = 0;
 429         *cols = 0;
 430         *width = 0;
 431         for (dimm_num = 0; dimm_num < num_dimm_banks; dimm_num++) {
 432                 if (dimm_ranks[dimm_num]) {
 433                         unsigned long t;
 434
 435                         /* Rows */
 436                         t = spd_read(iic0_dimm_addr[dimm_num], 3);
 437                         if (0 == *rows) {
 438                                 *rows = t;
 439                         } else if (t != *rows) {
 440                                 printf("ERROR: DRAM DIMM modules do not all "
 441                                        "have the same number of rows.\n\n");
 442                                 spd_ddr_init_hang();
 443                         }
 444                         /* Banks */
 445                         t = spd_read(iic0_dimm_addr[dimm_num], 17);
 446                         if (0 == *banks) {
 447                                 *banks = t;
 448                         } else if (t != *banks) {
 449                                 printf("ERROR: DRAM DIMM modules do not all "
 450                                        "have the same number of banks.\n\n");
 451                                 spd_ddr_init_hang();
 452                         }
 453                         /* Columns */
 454                         t = spd_read(iic0_dimm_addr[dimm_num], 4);
 455                         if (0 == *cols) {
 456                                 *cols = t;
 457                         } else if (t != *cols) {
 458                                 printf("ERROR: DRAM DIMM modules do not all "
 459                                        "have the same number of columns.\n\n");
 460                                 spd_ddr_init_hang();
 461                         }
 462                         /* Data width */
 463                         t = spd_read(iic0_dimm_addr[dimm_num], 6);
 464                         if (0 == *width) {
 465                                 *width = t;
 466                         } else if (t != *width) {
 467                                 printf("ERROR: DRAM DIMM modules do not all "
 468                                        "have the same data width.\n\n");
 469                                 spd_ddr_init_hang();
 470                         }
 471                 }
 472         }
 473         debug("Number of rows = %d\n", *rows);
 474         debug("Number of columns = %d\n", *cols);
 475         debug("Number of banks = %d\n", *banks);
 476         debug("Data width = %d\n", *width);
 477         if (*rows > 14) {
 478                 printf("ERROR: DRAM DIMM modules have %lu address rows.\n",
 479                        *rows);
 480                 printf("Only modules with 14 or fewer rows are supported.\n\n");
 481                 spd_ddr_init_hang();
 482         }
 483         if (4 != *banks && 8 != *banks) {
 484                 printf("ERROR: DRAM DIMM modules have %lu banks.\n", *banks);
 485                 printf("Only modules with 4 or 8 banks are supported.\n\n");
 486                 spd_ddr_init_hang();
 487         }
 488         if (*cols > 12) {
 489                 printf("ERROR: DRAM DIMM modules have %lu address columns.\n",
 490                        *cols);
 491                 printf("Only modules with 12 or fewer columns are "
 492                        "supported.\n\n");
 493                 spd_ddr_init_hang();
 494         }
 495         if (32 != *width && 40 != *width && 64 != *width && 72 != *width) {
 496                 printf("ERROR: DRAM DIMM modules have a width of %lu bit.\n",
 497                        *width);
 498                 printf("Only modules with widths of 32, 40, 64, and 72 bits "
 499                        "are supported.\n\n");
 500                 spd_ddr_init_hang();
 501         }
 502 }
 503
 504 /*------------------------------------------------------------------
 505  * Only 1.8V modules are supported.  This routine verifies this.
 506  *-----------------------------------------------------------------*/
 507 static void check_voltage_type(unsigned long dimm_ranks[],
 508                                unsigned char const iic0_dimm_addr[],
 509                                unsigned long num_dimm_banks)
 510 {
 511         unsigned long dimm_num;
 512         unsigned long voltage_type;
 513
 514         for (dimm_num = 0; dimm_num < num_dimm_banks; dimm_num++) {
 515                 if (dimm_ranks[dimm_num]) {
 516                         voltage_type = spd_read(iic0_dimm_addr[dimm_num], 8);
 517                         if (0x05 != voltage_type) {     /* 1.8V for DDR2 */
 518                                 printf("ERROR: Slot %lu provides 1.8V for DDR2 "
 519                                        "DIMMs.\n", dimm_num);
 520                                 switch (voltage_type) {
 521                                 case 0x00:
 522                                         printf("This DIMM is 5.0 Volt/TTL.\n");
 523                                         break;
 524                                 case 0x01:
 525                                         printf("This DIMM is LVTTL.\n");
 526                                         break;
 527                                 case 0x02:
 528                                         printf("This DIMM is 1.5 Volt.\n");
 529                                         break;
 530                                 case 0x03:
 531                                         printf("This DIMM is 3.3 Volt/TTL.\n");
 532                                         break;
 533                                 case 0x04:
 534                                         printf("This DIMM is 2.5 Volt.\n");
 535                                         break;
 536                                 default:
 537                                         printf("This DIMM is an unknown "
 538                                                "voltage.\n");
 539                                         break;
 540                                 }
 541                                 printf("Replace it with a 1.8V DDR2 DIMM.\n\n");
 542                                 spd_ddr_init_hang();
 543                         }
 544                 }
 545         }
 546 }
 547
 548 static void program_ddr0_03(unsigned long dimm_ranks[],
 549                             unsigned char const iic0_dimm_addr[],
 550                             unsigned long num_dimm_banks,
 551                             unsigned long sdram_freq,
 552                             unsigned long rows, unsigned long *cas_latency)
 553 {
 554         unsigned long dimm_num;
 555         unsigned long cas_index;
 556         unsigned long cycle_2_0_clk;
 557         unsigned long cycle_3_0_clk;
 558         unsigned long cycle_4_0_clk;
 559         unsigned long cycle_5_0_clk;
 560         unsigned long max_2_0_tcyc_ps = 100;
 561         unsigned long max_3_0_tcyc_ps = 100;
 562         unsigned long max_4_0_tcyc_ps = 100;
 563         unsigned long max_5_0_tcyc_ps = 100;
 564         unsigned char cas_available = 0x3C;     /* value for DDR2 */
 565         u32 ddr0_03 = DDR0_03_BSTLEN_ENCODE(0x2) | DDR0_03_INITAREF_ENCODE(0x2);
 566         unsigned int const tcyc_addr[3] = { 9, 23, 25 };
 567
 568         /*------------------------------------------------------------------
 569          * Get the board configuration info.
 570          *-----------------------------------------------------------------*/
 571         debug("sdram_freq = %d\n", sdram_freq);
 572
 573         /*------------------------------------------------------------------
 574          * Handle the timing.  We need to find the worst case timing of all
 575          * the dimm modules installed.
 576          *-----------------------------------------------------------------*/
 577         /* loop through all the DIMM slots on the board */
 578         for (dimm_num = 0; dimm_num < num_dimm_banks; dimm_num++) {
 579                 /* If a dimm is installed in a particular slot ... */
 580                 if (dimm_ranks[dimm_num]) {
 581                         unsigned char const cas_bit =
 582                             spd_read(iic0_dimm_addr[dimm_num], 18);
 583                         unsigned char cas_mask;
 584
 585                         cas_available &= cas_bit;
 586                         for (cas_mask = 0x80; cas_mask; cas_mask >>= 1) {
 587                                 if (cas_bit & cas_mask)
 588                                         break;
 589                         }
 590                         debug("cas_bit (SPD byte 18) = %02X, cas_mask = %02X\n",
 591                               cas_bit, cas_mask);
 592
 593                         for (cas_index = 0; cas_index < 3;
 594                              cas_mask >>= 1, cas_index++) {
 595                                 unsigned long cycle_time_ps;
 596
 597                                 if (!(cas_available & cas_mask)) {
 598                                         continue;
 599                                 }
 600                                 cycle_time_ps =
 601                                     get_tcyc(spd_read(iic0_dimm_addr[dimm_num],
 602                                                       tcyc_addr[cas_index]));
 603
 604                                 debug("cas_index = %d: cycle_time_ps = %d\n",
 605                                       cas_index, cycle_time_ps);
 606                                 /*
 607                                  * DDR2 devices use the following bitmask for CAS latency:
 608                                  *  Bit   7    6    5    4    3    2    1    0
 609                                  *       TBD  6.0  5.0  4.0  3.0  2.0  TBD  TBD
 610                                  */
 611                                 switch (cas_mask) {
 612                                 case 0x20:
 613                                         max_5_0_tcyc_ps =
 614                                             max(max_5_0_tcyc_ps, cycle_time_ps);
 615                                         break;
 616                                 case 0x10:
 617                                         max_4_0_tcyc_ps =
 618                                             max(max_4_0_tcyc_ps, cycle_time_ps);
 619                                         break;
 620                                 case 0x08:
 621                                         max_3_0_tcyc_ps =
 622                                             max(max_3_0_tcyc_ps, cycle_time_ps);
 623                                         break;
 624                                 case 0x04:
 625                                         max_2_0_tcyc_ps =
 626                                             max(max_2_0_tcyc_ps, cycle_time_ps);
 627                                         break;
 628                                 }
 629                         }
 630                 }
 631         }
 632         debug("cas_available (bit map) = 0x%02X\n", cas_available);
 633
 634         /*------------------------------------------------------------------
 635          * Set the SDRAM mode, SDRAM_MMODE
 636          *-----------------------------------------------------------------*/
 637
 638         /* add 10 here because of rounding problems */
 639         cycle_2_0_clk = MULDIV64(ONE_BILLION, 1000, max_2_0_tcyc_ps) + 10;
 640         cycle_3_0_clk = MULDIV64(ONE_BILLION, 1000, max_3_0_tcyc_ps) + 10;
 641         cycle_4_0_clk = MULDIV64(ONE_BILLION, 1000, max_4_0_tcyc_ps) + 10;
 642         cycle_5_0_clk = MULDIV64(ONE_BILLION, 1000, max_5_0_tcyc_ps) + 10;
 643         debug("cycle_2_0_clk = %d\n", cycle_2_0_clk);
 644         debug("cycle_3_0_clk = %d\n", cycle_3_0_clk);
 645         debug("cycle_4_0_clk = %d\n", cycle_4_0_clk);
 646         debug("cycle_5_0_clk = %d\n", cycle_5_0_clk);
 647
 648         if ((cas_available & 0x04) && (sdram_freq <= cycle_2_0_clk)) {
 649                 *cas_latency = 2;
 650                 ddr0_03 |= DDR0_03_CASLAT_ENCODE(0x2) |
 651                     DDR0_03_CASLAT_LIN_ENCODE(0x4);
 652         } else if ((cas_available & 0x08) && (sdram_freq <= cycle_3_0_clk)) {
 653                 *cas_latency = 3;
 654                 ddr0_03 |= DDR0_03_CASLAT_ENCODE(0x3) |
 655                     DDR0_03_CASLAT_LIN_ENCODE(0x6);
 656         } else if ((cas_available & 0x10) && (sdram_freq <= cycle_4_0_clk)) {
 657                 *cas_latency = 4;
 658                 ddr0_03 |= DDR0_03_CASLAT_ENCODE(0x4) |
 659                     DDR0_03_CASLAT_LIN_ENCODE(0x8);
 660         } else if ((cas_available & 0x20) && (sdram_freq <= cycle_5_0_clk)) {
 661                 *cas_latency = 5;
 662                 ddr0_03 |= DDR0_03_CASLAT_ENCODE(0x5) |
 663                     DDR0_03_CASLAT_LIN_ENCODE(0xA);
 664         } else {
 665                 printf("ERROR: Cannot find a supported CAS latency with the "
 666                        "installed DIMMs.\n");
 667                 printf("Only DDR2 DIMMs with CAS latencies of 2.0, 3.0, 4.0, "
 668                        "and 5.0 are supported.\n");
 669                 printf("Make sure the PLB speed is within the supported range "
 670                        "of the DIMMs.\n");
 671                 printf("sdram_freq=%ld cycle2=%ld cycle3=%ld cycle4=%ld "
 672                        "cycle5=%ld\n\n", sdram_freq, cycle_2_0_clk,
 673                        cycle_3_0_clk, cycle_4_0_clk, cycle_5_0_clk);
 674                 spd_ddr_init_hang();
 675         }
 676         debug("CAS latency = %d\n", *cas_latency);
 677         mtsdram(DDR0_03, ddr0_03);
 678 }
 679
 680 static void program_ddr0_04(unsigned long dimm_ranks[],
 681                             unsigned char const iic0_dimm_addr[],
 682                             unsigned long num_dimm_banks,
 683                             unsigned long sdram_freq)
 684 {
 685         unsigned long dimm_num;
 686         unsigned long t_rc_ps = 0;
 687         unsigned long t_rrd_ps = 0;
 688         unsigned long t_rtp_ps = 0;
 689         unsigned long t_rc_clk;
 690         unsigned long t_rrd_clk;
 691         unsigned long t_rtp_clk;
 692
 693         /*------------------------------------------------------------------
 694          * Handle the timing.  We need to find the worst case timing of all
 695          * the dimm modules installed.
 696          *-----------------------------------------------------------------*/
 697         /* loop through all the DIMM slots on the board */
 698         for (dimm_num = 0; dimm_num < num_dimm_banks; dimm_num++) {
 699                 /* If a dimm is installed in a particular slot ... */
 700                 if (dimm_ranks[dimm_num]) {
 701                         unsigned long ps;
 702
 703                         /* tRC */
 704                         ps = 1000 * spd_read(iic0_dimm_addr[dimm_num], 41);
 705                         switch (spd_read(iic0_dimm_addr[dimm_num], 40) >> 4) {
 706                         case 0x1:
 707                                 ps += 250;
 708                                 break;
 709                         case 0x2:
 710                                 ps += 333;
 711                                 break;
 712                         case 0x3:
 713                                 ps += 500;
 714                                 break;
 715                         case 0x4:
 716                                 ps += 667;
 717                                 break;
 718                         case 0x5:
 719                                 ps += 750;
 720                                 break;
 721                         }
 722                         t_rc_ps = max(t_rc_ps, ps);
 723                         /* tRRD */
 724                         ps = 250 * spd_read(iic0_dimm_addr[dimm_num], 28);
 725                         t_rrd_ps = max(t_rrd_ps, ps);
 726                         /* tRTP */
 727                         ps = 250 * spd_read(iic0_dimm_addr[dimm_num], 38);
 728                         t_rtp_ps = max(t_rtp_ps, ps);
 729                 }
 730         }
 731         debug("t_rc_ps  = %d\n", t_rc_ps);
 732         t_rc_clk = (MULDIV64(sdram_freq, t_rc_ps, ONE_BILLION) + 999) / 1000;
 733         debug("t_rrd_ps = %d\n", t_rrd_ps);
 734         t_rrd_clk = (MULDIV64(sdram_freq, t_rrd_ps, ONE_BILLION) + 999) / 1000;
 735         debug("t_rtp_ps = %d\n", t_rtp_ps);
 736         t_rtp_clk = (MULDIV64(sdram_freq, t_rtp_ps, ONE_BILLION) + 999) / 1000;
 737         mtsdram(DDR0_04, DDR0_04_TRC_ENCODE(t_rc_clk) |
 738                 DDR0_04_TRRD_ENCODE(t_rrd_clk) |
 739                 DDR0_04_TRTP_ENCODE(t_rtp_clk));
 740 }
 741
 742 static void program_ddr0_05(unsigned long dimm_ranks[],
 743                             unsigned char const iic0_dimm_addr[],
 744                             unsigned long num_dimm_banks,
 745                             unsigned long sdram_freq)
 746 {
 747         unsigned long dimm_num;
 748         unsigned long t_rp_ps = 0;
 749         unsigned long t_ras_ps = 0;
 750         unsigned long t_rp_clk;
 751         unsigned long t_ras_clk;
 752         u32 ddr0_05 = DDR0_05_TMRD_ENCODE(0x2) | DDR0_05_TEMRS_ENCODE(0x2);
 753
 754         /*------------------------------------------------------------------
 755          * Handle the timing.  We need to find the worst case timing of all
 756          * the dimm modules installed.
 757          *-----------------------------------------------------------------*/
 758         /* loop through all the DIMM slots on the board */
 759         for (dimm_num = 0; dimm_num < num_dimm_banks; dimm_num++) {
 760                 /* If a dimm is installed in a particular slot ... */
 761                 if (dimm_ranks[dimm_num]) {
 762                         unsigned long ps;
 763
 764                         /* tRP */
 765                         ps = 250 * spd_read(iic0_dimm_addr[dimm_num], 27);
 766                         t_rp_ps = max(t_rp_ps, ps);
 767                         /* tRAS */
 768                         ps = 1000 * spd_read(iic0_dimm_addr[dimm_num], 30);
 769                         t_ras_ps = max(t_ras_ps, ps);
 770                 }
 771         }
 772         debug("t_rp_ps  = %d\n", t_rp_ps);
 773         t_rp_clk = (MULDIV64(sdram_freq, t_rp_ps, ONE_BILLION) + 999) / 1000;
 774         debug("t_ras_ps = %d\n", t_ras_ps);
 775         t_ras_clk = (MULDIV64(sdram_freq, t_ras_ps, ONE_BILLION) + 999) / 1000;
 776         mtsdram(DDR0_05, ddr0_05 | DDR0_05_TRP_ENCODE(t_rp_clk) |
 777                 DDR0_05_TRAS_MIN_ENCODE(t_ras_clk));
 778 }
 779
 780 static void program_ddr0_06(unsigned long dimm_ranks[],
 781                             unsigned char const iic0_dimm_addr[],
 782                             unsigned long num_dimm_banks,
 783                             unsigned long sdram_freq)
 784 {
 785         unsigned long dimm_num;
 786         unsigned char spd_40;
 787         unsigned long t_wtr_ps = 0;
 788         unsigned long t_rfc_ps = 0;
 789         unsigned long t_wtr_clk;
 790         unsigned long t_rfc_clk;
 791         u32 ddr0_06 =
 792             DDR0_06_WRITEINTERP_ENCODE(0x1) | DDR0_06_TDLL_ENCODE(200);
 793
 794         /*------------------------------------------------------------------
 795          * Handle the timing.  We need to find the worst case timing of all
 796          * the dimm modules installed.
 797          *-----------------------------------------------------------------*/
 798         /* loop through all the DIMM slots on the board */
 799         for (dimm_num = 0; dimm_num < num_dimm_banks; dimm_num++) {
 800                 /* If a dimm is installed in a particular slot ... */
 801                 if (dimm_ranks[dimm_num]) {
 802                         unsigned long ps;
 803
 804                         /* tWTR */
 805                         ps = 250 * spd_read(iic0_dimm_addr[dimm_num], 37);
 806                         t_wtr_ps = max(t_wtr_ps, ps);
 807                         /* tRFC */
 808                         ps = 1000 * spd_read(iic0_dimm_addr[dimm_num], 42);
 809                         spd_40 = spd_read(iic0_dimm_addr[dimm_num], 40);
 810                         ps += 256000 * (spd_40 & 0x01);
 811                         switch ((spd_40 & 0x0E) >> 1) {
 812                         case 0x1:
 813                                 ps += 250;
 814                                 break;
 815                         case 0x2:
 816                                 ps += 333;
 817                                 break;
 818                         case 0x3:
 819                                 ps += 500;
 820                                 break;
 821                         case 0x4:
 822                                 ps += 667;
 823                                 break;
 824                         case 0x5:
 825                                 ps += 750;
 826                                 break;
 827                         }
 828                         t_rfc_ps = max(t_rfc_ps, ps);
 829                 }
 830         }
 831         debug("t_wtr_ps = %d\n", t_wtr_ps);
 832         t_wtr_clk = (MULDIV64(sdram_freq, t_wtr_ps, ONE_BILLION) + 999) / 1000;
 833         debug("t_rfc_ps = %d\n", t_rfc_ps);
 834         t_rfc_clk = (MULDIV64(sdram_freq, t_rfc_ps, ONE_BILLION) + 999) / 1000;
 835         mtsdram(DDR0_06, ddr0_06 | DDR0_06_TWTR_ENCODE(t_wtr_clk) |
 836                 DDR0_06_TRFC_ENCODE(t_rfc_clk));
 837 }
 838
 839 static void program_ddr0_10(unsigned long dimm_ranks[], unsigned long ranks)
 840 {
 841         unsigned long csmap;
 842
 843         if (2 == ranks) {
 844                 /* Both chip selects in use */
 845                 csmap = 0x03;
 846         } else {
 847                 /* One chip select in use */
 848                 csmap = (1 == dimm_ranks[0]) ? 0x1 : 0x2;
 849         }
 850         mtsdram(DDR0_10, DDR0_10_WRITE_MODEREG_ENCODE(0x0) |
 851                 DDR0_10_CS_MAP_ENCODE(csmap) |
 852                 DDR0_10_OCD_ADJUST_PUP_CS_0_ENCODE(0));
 853 }
 854
 855 static void program_ddr0_11(unsigned long sdram_freq)
 856 {
 857         unsigned long const t_xsnr_ps = 200000; /* 200 ns */
 858         unsigned long t_xsnr_clk;
 859
 860         debug("t_xsnr_ps = %d\n", t_xsnr_ps);
 861         t_xsnr_clk =
 862             (MULDIV64(sdram_freq, t_xsnr_ps, ONE_BILLION) + 999) / 1000;
 863         mtsdram(DDR0_11, DDR0_11_SREFRESH_ENCODE(0) |
 864                 DDR0_11_TXSNR_ENCODE(t_xsnr_clk) | DDR0_11_TXSR_ENCODE(200));
 865 }
 866
 867 static void program_ddr0_22(unsigned long dimm_ranks[],
 868                             unsigned char const iic0_dimm_addr[],
 869                             unsigned long num_dimm_banks, unsigned long width)
 870 {
 871 #if defined(CONFIG_DDR_ECC)
 872         unsigned long dimm_num;
 873         unsigned long ecc_available = width >= 64;
 874         u32 ddr0_22 = DDR0_22_DQS_OUT_SHIFT_BYPASS_ENCODE(0x26) |
 875             DDR0_22_DQS_OUT_SHIFT_ENCODE(DQS_OUT_SHIFT) |
 876             DDR0_22_DLL_DQS_BYPASS_8_ENCODE(DLL_DQS_BYPASS);
 877
 878         /* loop through all the DIMM slots on the board */
 879         for (dimm_num = 0; dimm_num < num_dimm_banks; dimm_num++) {
 880                 /* If a dimm is installed in a particular slot ... */
 881                 if (dimm_ranks[dimm_num]) {
 882                         /* Check for ECC */
 883                         if (0 == (spd_read(iic0_dimm_addr[dimm_num], 11) &
 884                                   0x02)) {
 885                                 ecc_available = FALSE;
 886                         }
 887                 }
 888         }
 889         if (ecc_available) {
 890                 debug("ECC found on all DIMMs present\n");
 891                 mtsdram(DDR0_22, ddr0_22 | DDR0_22_CTRL_RAW_ENCODE(0x3));
 892         } else {
 893                 debug("ECC not found on some or all DIMMs present\n");
 894                 mtsdram(DDR0_22, ddr0_22 | DDR0_22_CTRL_RAW_ENCODE(0x0));
 895         }
 896 #else
 897         mtsdram(DDR0_22, DDR0_22_CTRL_RAW_ENCODE(0x0) |
 898                 DDR0_22_DQS_OUT_SHIFT_BYPASS_ENCODE(0x26) |
 899                 DDR0_22_DQS_OUT_SHIFT_ENCODE(DQS_OUT_SHIFT) |
 900                 DDR0_22_DLL_DQS_BYPASS_8_ENCODE(DLL_DQS_BYPASS));
 901 #endif /* defined(CONFIG_DDR_ECC) */
 902 }
 903
 904 static void program_ddr0_24(unsigned long ranks)
 905 {
 906         u32 ddr0_24 = DDR0_24_RTT_PAD_TERMINATION_ENCODE(0x1) | /* 75 ohm */
 907             DDR0_24_ODT_RD_MAP_CS1_ENCODE(0x0);
 908
 909         if (2 == ranks) {
 910                 /* Both chip selects in use */
 911                 ddr0_24 |= DDR0_24_ODT_WR_MAP_CS1_ENCODE(0x1) |
 912                     DDR0_24_ODT_WR_MAP_CS0_ENCODE(0x2);
 913         } else {
 914                 /* One chip select in use */
 915                 /* One of the two fields added to ddr0_24 is a "don't care" */
 916                 ddr0_24 |= DDR0_24_ODT_WR_MAP_CS1_ENCODE(0x2) |
 917                     DDR0_24_ODT_WR_MAP_CS0_ENCODE(0x1);
 918         }
 919         mtsdram(DDR0_24, ddr0_24);
 920 }
 921
 922 static void program_ddr0_26(unsigned long sdram_freq)
 923 {
 924         unsigned long const t_ref_ps = 7800000; /* 7.8 us. refresh */
 925         /* TODO: check definition of tRAS_MAX */
 926         unsigned long const t_ras_max_ps = 9 * t_ref_ps;
 927         unsigned long t_ras_max_clk;
 928         unsigned long t_ref_clk;
 929
 930         /* Round down t_ras_max_clk and t_ref_clk */
 931         debug("t_ras_max_ps = %d\n", t_ras_max_ps);
 932         t_ras_max_clk = MULDIV64(sdram_freq, t_ras_max_ps, ONE_BILLION) / 1000;
 933         debug("t_ref_ps     = %d\n", t_ref_ps);
 934         t_ref_clk = MULDIV64(sdram_freq, t_ref_ps, ONE_BILLION) / 1000;
 935         mtsdram(DDR0_26, DDR0_26_TRAS_MAX_ENCODE(t_ras_max_clk) |
 936                 DDR0_26_TREF_ENCODE(t_ref_clk));
 937 }
 938
 939 static void program_ddr0_27(unsigned long sdram_freq)
 940 {
 941         unsigned long const t_init_ps = 200000000;      /* 200 us. init */
 942         unsigned long t_init_clk;
 943
 944         debug("t_init_ps = %d\n", t_init_ps);
 945         t_init_clk =
 946             (MULDIV64(sdram_freq, t_init_ps, ONE_BILLION) + 999) / 1000;
 947         mtsdram(DDR0_27, DDR0_27_EMRS_DATA_ENCODE(0x0000) |
 948                 DDR0_27_TINIT_ENCODE(t_init_clk));
 949 }
 950
 951 static void program_ddr0_43(unsigned long dimm_ranks[],
 952                             unsigned char const iic0_dimm_addr[],
 953                             unsigned long num_dimm_banks,
 954                             unsigned long sdram_freq,
 955                             unsigned long cols, unsigned long banks)
 956 {
 957         unsigned long dimm_num;
 958         unsigned long t_wr_ps = 0;
 959         unsigned long t_wr_clk;
 960         u32 ddr0_43 = DDR0_43_APREBIT_ENCODE(10) |
 961             DDR0_43_COLUMN_SIZE_ENCODE(12 - cols) |
 962             DDR0_43_EIGHT_BANK_MODE_ENCODE(8 == banks ? 1 : 0);
 963
 964         /*------------------------------------------------------------------
 965          * Handle the timing.  We need to find the worst case timing of all
 966          * the dimm modules installed.
 967          *-----------------------------------------------------------------*/
 968         /* loop through all the DIMM slots on the board */
 969         for (dimm_num = 0; dimm_num < num_dimm_banks; dimm_num++) {
 970                 /* If a dimm is installed in a particular slot ... */
 971                 if (dimm_ranks[dimm_num]) {
 972                         unsigned long ps;
 973
 974                         ps = 250 * spd_read(iic0_dimm_addr[dimm_num], 36);
 975                         t_wr_ps = max(t_wr_ps, ps);
 976                 }
 977         }
 978         debug("t_wr_ps = %d\n", t_wr_ps);
 979         t_wr_clk = (MULDIV64(sdram_freq, t_wr_ps, ONE_BILLION) + 999) / 1000;
 980         mtsdram(DDR0_43, ddr0_43 | DDR0_43_TWR_ENCODE(t_wr_clk));
 981 }
 982
 983 static void program_ddr0_44(unsigned long dimm_ranks[],
 984                             unsigned char const iic0_dimm_addr[],
 985                             unsigned long num_dimm_banks,
 986                             unsigned long sdram_freq)
 987 {
 988         unsigned long dimm_num;
 989         unsigned long t_rcd_ps = 0;
 990         unsigned long t_rcd_clk;
 991
 992         /*------------------------------------------------------------------
 993          * Handle the timing.  We need to find the worst case timing of all
 994          * the dimm modules installed.
 995          *-----------------------------------------------------------------*/
 996         /* loop through all the DIMM slots on the board */
 997         for (dimm_num = 0; dimm_num < num_dimm_banks; dimm_num++) {
 998                 /* If a dimm is installed in a particular slot ... */
 999                 if (dimm_ranks[dimm_num]) {
1000                         unsigned long ps;
1001
1002                         ps = 250 * spd_read(iic0_dimm_addr[dimm_num], 29);
1003                         t_rcd_ps = max(t_rcd_ps, ps);
1004                 }
1005         }
1006         debug("t_rcd_ps = %d\n", t_rcd_ps);
1007         t_rcd_clk = (MULDIV64(sdram_freq, t_rcd_ps, ONE_BILLION) + 999) / 1000;
1008         mtsdram(DDR0_44, DDR0_44_TRCD_ENCODE(t_rcd_clk));
1009 }
1010
1011 /*-----------------------------------------------------------------------------+
1012  * initdram.  Initializes the 440EPx/GPx DDR SDRAM controller.
1013  * Note: This routine runs from flash with a stack set up in the chip's
1014  * sram space.  It is important that the routine does not require .sbss, .bss or
1015  * .data sections.  It also cannot call routines that require these sections.
1016  *-----------------------------------------------------------------------------*/
1017 /*-----------------------------------------------------------------------------
1018  * Function:     initdram
1019  * Description:  Configures SDRAM memory banks for DDR operation.
1020  *               Auto Memory Configuration option reads the DDR SDRAM EEPROMs
1021  *               via the IIC bus and then configures the DDR SDRAM memory
1022  *               banks appropriately. If Auto Memory Configuration is
1023  *               not used, it is assumed that no DIMM is plugged
1024  *-----------------------------------------------------------------------------*/
1025 phys_size_t initdram(int board_type)
1026 {
1027         unsigned char const iic0_dimm_addr[] = SPD_EEPROM_ADDRESS;
1028         unsigned long dimm_ranks[MAXDIMMS];
1029         unsigned long ranks;
1030         unsigned long rows;
1031         unsigned long banks;
1032         unsigned long cols;
1033         unsigned long width;
1034         unsigned long const sdram_freq = get_bus_freq(0);
1035         unsigned long const num_dimm_banks = sizeof(iic0_dimm_addr);    /* on board dimm banks */
1036         unsigned long cas_latency = 0;  /* to quiet initialization warning */
1037         unsigned long dram_size;
1038
1039         debug("\nEntering initdram()\n");
1040
1041         /*------------------------------------------------------------------
1042          * Stop the DDR-SDRAM controller.
1043          *-----------------------------------------------------------------*/
1044         mtsdram(DDR0_02, DDR0_02_START_ENCODE(0));
1045
1046         /*
1047          * Make sure I2C controller is initialized
1048          * before continuing.
1049          */
1050         /* switch to correct I2C bus */
1051         I2C_SET_BUS(CONFIG_SYS_SPD_BUS_NUM);
1052         i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
1053
1054         /*------------------------------------------------------------------
1055          * Clear out the serial presence detect buffers.
1056          * Perform IIC reads from the dimm.  Fill in the spds.
1057          * Check to see if the dimm slots are populated
1058          *-----------------------------------------------------------------*/
1059         get_spd_info(dimm_ranks, &ranks, iic0_dimm_addr, num_dimm_banks);
1060
1061         /*------------------------------------------------------------------
1062          * Check the frequency supported for the dimms plugged.
1063          *-----------------------------------------------------------------*/
1064         check_frequency(dimm_ranks, iic0_dimm_addr, num_dimm_banks, sdram_freq);
1065
1066         /*------------------------------------------------------------------
1067          * Check and get size information.
1068          *-----------------------------------------------------------------*/
1069         get_dimm_size(dimm_ranks, iic0_dimm_addr, num_dimm_banks, &rows, &banks,
1070                       &cols, &width);
1071
1072         /*------------------------------------------------------------------
1073          * Check the voltage type for the dimms plugged.
1074          *-----------------------------------------------------------------*/
1075         check_voltage_type(dimm_ranks, iic0_dimm_addr, num_dimm_banks);
1076
1077         /*------------------------------------------------------------------
1078          * Program registers for SDRAM controller.
1079          *-----------------------------------------------------------------*/
1080         mtsdram(DDR0_00, DDR0_00_DLL_INCREMENT_ENCODE(0x19) |
1081                 DDR0_00_DLL_START_POINT_DECODE(0x0A));
1082
1083         mtsdram(DDR0_01, DDR0_01_PLB0_DB_CS_LOWER_ENCODE(0x01) |
1084                 DDR0_01_PLB0_DB_CS_UPPER_ENCODE(0x00) |
1085                 DDR0_01_INT_MASK_ENCODE(0xFF));
1086
1087         program_ddr0_03(dimm_ranks, iic0_dimm_addr, num_dimm_banks, sdram_freq,
1088                         rows, &cas_latency);
1089
1090         program_ddr0_04(dimm_ranks, iic0_dimm_addr, num_dimm_banks, sdram_freq);
1091
1092         program_ddr0_05(dimm_ranks, iic0_dimm_addr, num_dimm_banks, sdram_freq);
1093
1094         program_ddr0_06(dimm_ranks, iic0_dimm_addr, num_dimm_banks, sdram_freq);
1095
1096         /*
1097          * TODO: tFAW not found in SPD.  Value of 13 taken from Sequoia
1098          * board SDRAM, but may be overly conservative.
1099          */
1100         mtsdram(DDR0_07, DDR0_07_NO_CMD_INIT_ENCODE(0) |
1101                 DDR0_07_TFAW_ENCODE(13) |
1102                 DDR0_07_AUTO_REFRESH_MODE_ENCODE(1) |
1103                 DDR0_07_AREFRESH_ENCODE(0));
1104
1105         mtsdram(DDR0_08, DDR0_08_WRLAT_ENCODE(cas_latency - 1) |
1106                 DDR0_08_TCPD_ENCODE(200) | DDR0_08_DQS_N_EN_ENCODE(0) |
1107                 DDR0_08_DDRII_ENCODE(1));
1108
1109         mtsdram(DDR0_09, DDR0_09_OCD_ADJUST_PDN_CS_0_ENCODE(0x00) |
1110                 DDR0_09_RTT_0_ENCODE(0x1) |
1111                 DDR0_09_WR_DQS_SHIFT_BYPASS_ENCODE(0x1D) |
1112                 DDR0_09_WR_DQS_SHIFT_ENCODE(DQS_OUT_SHIFT - 0x20));
1113
1114         program_ddr0_10(dimm_ranks, ranks);
1115
1116         program_ddr0_11(sdram_freq);
1117
1118         mtsdram(DDR0_12, DDR0_12_TCKE_ENCODE(3));
1119
1120         mtsdram(DDR0_14, DDR0_14_DLL_BYPASS_MODE_ENCODE(0) |
1121                 DDR0_14_REDUC_ENCODE(width <= 40 ? 1 : 0) |
1122                 DDR0_14_REG_DIMM_ENABLE_ENCODE(0));
1123
1124         mtsdram(DDR0_17, DDR0_17_DLL_DQS_DELAY_0_ENCODE(DLL_DQS_DELAY));
1125
1126         mtsdram(DDR0_18, DDR0_18_DLL_DQS_DELAY_4_ENCODE(DLL_DQS_DELAY) |
1127                 DDR0_18_DLL_DQS_DELAY_3_ENCODE(DLL_DQS_DELAY) |
1128                 DDR0_18_DLL_DQS_DELAY_2_ENCODE(DLL_DQS_DELAY) |
1129                 DDR0_18_DLL_DQS_DELAY_1_ENCODE(DLL_DQS_DELAY));
1130
1131         mtsdram(DDR0_19, DDR0_19_DLL_DQS_DELAY_8_ENCODE(DLL_DQS_DELAY) |
1132                 DDR0_19_DLL_DQS_DELAY_7_ENCODE(DLL_DQS_DELAY) |
1133                 DDR0_19_DLL_DQS_DELAY_6_ENCODE(DLL_DQS_DELAY) |
1134                 DDR0_19_DLL_DQS_DELAY_5_ENCODE(DLL_DQS_DELAY));
1135
1136         mtsdram(DDR0_20, DDR0_20_DLL_DQS_BYPASS_3_ENCODE(DLL_DQS_BYPASS) |
1137                 DDR0_20_DLL_DQS_BYPASS_2_ENCODE(DLL_DQS_BYPASS) |
1138                 DDR0_20_DLL_DQS_BYPASS_1_ENCODE(DLL_DQS_BYPASS) |
1139                 DDR0_20_DLL_DQS_BYPASS_0_ENCODE(DLL_DQS_BYPASS));
1140
1141         mtsdram(DDR0_21, DDR0_21_DLL_DQS_BYPASS_7_ENCODE(DLL_DQS_BYPASS) |
1142                 DDR0_21_DLL_DQS_BYPASS_6_ENCODE(DLL_DQS_BYPASS) |
1143                 DDR0_21_DLL_DQS_BYPASS_5_ENCODE(DLL_DQS_BYPASS) |
1144                 DDR0_21_DLL_DQS_BYPASS_4_ENCODE(DLL_DQS_BYPASS));
1145
1146         program_ddr0_22(dimm_ranks, iic0_dimm_addr, num_dimm_banks, width);
1147
1148         mtsdram(DDR0_23, DDR0_23_ODT_RD_MAP_CS0_ENCODE(0x0) |
1149                 DDR0_23_FWC_ENCODE(0));
1150
1151         program_ddr0_24(ranks);
1152
1153         program_ddr0_26(sdram_freq);
1154
1155         program_ddr0_27(sdram_freq);
1156
1157         mtsdram(DDR0_28, DDR0_28_EMRS3_DATA_ENCODE(0x0000) |
1158                 DDR0_28_EMRS2_DATA_ENCODE(0x0000));
1159
1160         mtsdram(DDR0_31, DDR0_31_XOR_CHECK_BITS_ENCODE(0x0000));
1161
1162         mtsdram(DDR0_42, DDR0_42_ADDR_PINS_ENCODE(14 - rows) |
1163                 DDR0_42_CASLAT_LIN_GATE_ENCODE(2 * cas_latency));
1164
1165         program_ddr0_43(dimm_ranks, iic0_dimm_addr, num_dimm_banks, sdram_freq,
1166                         cols, banks);
1167
1168         program_ddr0_44(dimm_ranks, iic0_dimm_addr, num_dimm_banks, sdram_freq);
1169
1170         denali_sdram_register_dump();
1171
1172         dram_size = (width >= 64) ? 8 : 4;
1173         dram_size *= 1 << cols;
1174         dram_size *= banks;
1175         dram_size *= 1 << rows;
1176         dram_size *= ranks;
1177         debug("dram_size = %lu\n", dram_size);
1178
1179         /* Start the SDRAM controler */
1180         mtsdram(DDR0_02, DDR0_02_START_ENCODE(1));
1181         denali_wait_for_dlllock();
1182
1183 #if defined(CONFIG_DDR_DATA_EYE)
1184         /*
1185          * Map the first 1 MiB of memory in the TLB, and perform the data eye
1186          * search.
1187          */
1188         program_tlb(0, CONFIG_SYS_SDRAM_BASE, TLB_1MB_SIZE, TLB_WORD2_I_ENABLE);
1189         denali_core_search_data_eye();
1190         denali_sdram_register_dump();
1191         remove_tlb(CONFIG_SYS_SDRAM_BASE, TLB_1MB_SIZE);
1192 #endif
1193
1194 #if defined(CONFIG_ZERO_SDRAM) || defined(CONFIG_DDR_ECC)
1195         program_tlb(0, CONFIG_SYS_SDRAM_BASE, dram_size, 0);
1196         sync();
1197         /* Zero the memory */
1198         debug("Zeroing SDRAM...");
1199 #if defined(CONFIG_SYS_MEM_TOP_HIDE)
1200         dcbz_area(CONFIG_SYS_SDRAM_BASE, dram_size - CONFIG_SYS_MEM_TOP_HIDE);
1201 #else
1202 #error Please define CONFIG_SYS_MEM_TOP_HIDE (see README) in your board config file
1203 #endif
1204         /* Write modified dcache lines back to memory */
1205         clean_dcache_range(CONFIG_SYS_SDRAM_BASE, CONFIG_SYS_SDRAM_BASE + dram_size - CONFIG_SYS_MEM_TOP_HIDE);
1206         debug("Completed\n");
1207         sync();
1208         remove_tlb(CONFIG_SYS_SDRAM_BASE, dram_size);
1209
1210 #if defined(CONFIG_DDR_ECC)
1211         /*
1212          * If ECC is enabled, clear and enable interrupts
1213          */
1214         if (is_ecc_enabled()) {
1215                 u32 val;
1216
1217                 sync();
1218                 /* Clear error status */
1219                 mfsdram(DDR0_00, val);
1220                 mtsdram(DDR0_00, val | DDR0_00_INT_ACK_ALL);
1221                 /* Set 'int_mask' parameter to functionnal value */
1222                 mfsdram(DDR0_01, val);
1223                 mtsdram(DDR0_01, (val & ~DDR0_01_INT_MASK_MASK) |
1224                         DDR0_01_INT_MASK_ALL_OFF);
1225 #if defined(CONFIG_DDR_DATA_EYE)
1226                 /*
1227                  * Running denali_core_search_data_eye() when ECC is enabled
1228                  * causes non-ECC machine checks.  This clears them.
1229                  */
1230                 print_mcsr();
1231                 mtspr(SPRN_MCSR, mfspr(SPRN_MCSR));
1232                 print_mcsr();
1233 #endif
1234                 sync();
1235         }
1236 #endif /* defined(CONFIG_DDR_ECC) */
1237 #endif /* defined(CONFIG_ZERO_SDRAM) || defined(CONFIG_DDR_ECC) */
1238
1239         program_tlb(0, CONFIG_SYS_SDRAM_BASE, dram_size, MY_TLB_WORD2_I_ENABLE);
1240         return dram_size;
1241 }
1242
1243 void board_add_ram_info(int use_default)
1244 {
1245         u32 val;
1246
1247         printf(" (ECC");
1248         if (!is_ecc_enabled()) {
1249                 printf(" not");
1250         }
1251         printf(" enabled, %ld MHz", (2 * get_bus_freq(0)) / 1000000);
1252
1253         mfsdram(DDR0_03, val);
1254         printf(", CL%d)", DDR0_03_CASLAT_LIN_DECODE(val) >> 1);
1255 }
1256 #endif /* CONFIG_SPD_EEPROM */