src/northbridge/intel/e7520/raminit.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * Copyright (C) 2005 Eric W. Biederman and Tom Zimmerman
   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 version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  18  */
  19
  20 #include <cpu/x86/mtrr.h>
  21 #include <cpu/x86/cache.h>
  22 #include <stdlib.h>
  23 #include "raminit.h"
  24 #include "e7520.h"
  25 #include <pc80/mc146818rtc.h>
  26 #if CONFIG_HAVE_OPTION_TABLE
  27 #include "option_table.h"
  28 #endif
  29
  30 #define BAR 0x40000000
  31
  32 static void sdram_set_registers(const struct mem_controller *ctrl)
  33 {
  34         static const unsigned int register_values[] = {
  35
  36                 /* CKDIS 0x8c disable clocks */
  37         PCI_ADDR(0, 0x00, 0, CKDIS), 0xffff0000, 0x0000ffff,
  38
  39                 /* 0x9c Device present and extended RAM control
  40                  * DEVPRES is very touchy, hard code the initialization
  41                  * of PCI-E ports here.
  42                  */
  43         PCI_ADDR(0, 0x00, 0, DEVPRES), 0x00000000, 0x07020801 | DEVPRES_CONFIG,
  44
  45                 /* 0xc8 Remap RAM base and limit off */
  46         PCI_ADDR(0, 0x00, 0, REMAPLIMIT), 0x00000000, 0x03df0000,
  47
  48                 /* ??? */
  49         PCI_ADDR(0, 0x00, 0, 0xd8), 0x00000000, 0xb5930000,
  50         PCI_ADDR(0, 0x00, 0, 0xe8), 0x00000000, 0x00004a2a,
  51
  52                 /* 0x50 scrub */
  53         PCI_ADDR(0, 0x00, 0, MCHCFG0), 0xfce0ffff, 0x00006000, /* 6000 */
  54
  55                 /* 0x58 0x5c PAM */
  56         PCI_ADDR(0, 0x00, 0, PAM-1), 0xcccccc7f, 0x33333000,
  57         PCI_ADDR(0, 0x00, 0, PAM+3), 0xcccccccc, 0x33333333,
  58
  59                 /* 0xf4 */
  60         PCI_ADDR(0, 0x00, 0, DEVPRES1), 0xffbffff, (1<<22)|(6<<2) | DEVPRES1_CONFIG,
  61
  62                 /* 0x14 */
  63         PCI_ADDR(0, 0x00, 0, IURBASE), 0x00000fff, BAR |0,
  64         };
  65         int i;
  66         int max;
  67
  68         max = ARRAY_SIZE(register_values);
  69         for(i = 0; i < max; i += 3) {
  70                 device_t dev;
  71                 unsigned where;
  72                 unsigned long reg;
  73                 dev = (register_values[i] & ~0xff) - PCI_DEV(0, 0x00, 0) + PCI_DEV(0, 0x00, 0);
  74                 where = register_values[i] & 0xff;
  75                 reg = pci_read_config32(dev, where);
  76                 reg &= register_values[i+1];
  77                 reg |= register_values[i+2];
  78                 pci_write_config32(dev, where, reg);
  79         }
  80         print_spew("done.\n");
  81 }
  82
  83 struct dimm_size {
  84         unsigned long side1;
  85         unsigned long side2;
  86 };
  87
  88 static struct dimm_size spd_get_dimm_size(unsigned device)
  89 {
  90         /* Calculate the log base 2 size of a DIMM in bits */
  91         struct dimm_size sz;
  92         int value, low, ddr2;
  93         sz.side1 = 0;
  94         sz.side2 = 0;
  95
  96         /* test for ddr2 */
  97         ddr2=0;
  98         value = spd_read_byte(device, 2);       /* type */
  99         if (value < 0) goto hw_err;
 100         if (value == 8) ddr2 = 1;
 101
 102         /* Note it might be easier to use byte 31 here, it has the DIMM size as
 103          * a multiple of 4MB.  The way we do it now we can size both
 104          * sides of an assymetric dimm.
 105          */
 106         value = spd_read_byte(device, 3);       /* rows */
 107         if (value < 0) goto hw_err;
 108         if ((value & 0xf) == 0) goto val_err;
 109         sz.side1 += value & 0xf;
 110
 111         value = spd_read_byte(device, 4);       /* columns */
 112         if (value < 0) goto hw_err;
 113         if ((value & 0xf) == 0) goto val_err;
 114         sz.side1 += value & 0xf;
 115
 116         value = spd_read_byte(device, 17);      /* banks */
 117         if (value < 0) goto hw_err;
 118         if ((value & 0xff) == 0) goto val_err;
 119         sz.side1 += log2(value & 0xff);
 120
 121         /* Get the module data width and convert it to a power of two */
 122         value = spd_read_byte(device, 7);       /* (high byte) */
 123         if (value < 0) goto hw_err;
 124         value &= 0xff;
 125         value <<= 8;
 126
 127         low = spd_read_byte(device, 6); /* (low byte) */
 128         if (low < 0) goto hw_err;
 129         value = value | (low & 0xff);
 130         if ((value != 72) && (value != 64)) goto val_err;
 131         sz.side1 += log2(value);
 132
 133         /* side 2 */
 134         value = spd_read_byte(device, 5);       /* number of physical banks */
 135
 136         if (value < 0) goto hw_err;
 137         value &= 7;
 138         if(ddr2) value++;
 139         if (value == 1) goto out;
 140         if (value != 2) goto val_err;
 141
 142         /* Start with the symmetrical case */
 143         sz.side2 = sz.side1;
 144
 145         value = spd_read_byte(device, 3);       /* rows */
 146         if (value < 0) goto hw_err;
 147         if ((value & 0xf0) == 0) goto out;      /* If symmetrical we are done */
 148         sz.side2 -= (value & 0x0f);             /* Subtract out rows on side 1 */
 149         sz.side2 += ((value >> 4) & 0x0f);      /* Add in rows on side 2 */
 150
 151         value = spd_read_byte(device, 4);       /* columns */
 152         if (value < 0) goto hw_err;
 153         if ((value & 0xff) == 0) goto val_err;
 154         sz.side2 -= (value & 0x0f);             /* Subtract out columns on side 1 */
 155         sz.side2 += ((value >> 4) & 0x0f);      /* Add in columsn on side 2 */
 156         goto out;
 157
 158  val_err:
 159         die("Bad SPD value\n");
 160         /* If an hw_error occurs report that I have no memory */
 161 hw_err:
 162         sz.side1 = 0;
 163         sz.side2 = 0;
 164 out:
 165         return sz;
 166
 167 }
 168
 169 static long spd_set_ram_size(const struct mem_controller *ctrl, long dimm_mask)
 170 {
 171         int i;
 172         int cum;
 173
 174         for(i = cum = 0; i < DIMM_SOCKETS; i++) {
 175                 struct dimm_size sz;
 176                 if (dimm_mask & (1 << i)) {
 177                         sz = spd_get_dimm_size(ctrl->channel0[i]);
 178                         if (sz.side1 < 29) {
 179                                 return -1; /* Report SPD error */
 180                         }
 181                         /* convert bits to multiples of 64MB */
 182                         sz.side1 -= 29;
 183                         cum += (1 << sz.side1);
 184                         /* DRB = 0x60 */
 185                         pci_write_config8(PCI_DEV(0, 0x00, 0), DRB + (i*2), cum);
 186                         if( sz.side2 > 28) {
 187                                 sz.side2 -= 29;
 188                                 cum += (1 << sz.side2);
 189                         }
 190                         pci_write_config8(PCI_DEV(0, 0x00, 0), DRB+1 + (i*2), cum);
 191                 }
 192                 else {
 193                         pci_write_config8(PCI_DEV(0, 0x00, 0), DRB + (i*2), cum);
 194                         pci_write_config8(PCI_DEV(0, 0x00, 0), DRB+1 + (i*2), cum);
 195                 }
 196         }
 197         /* set TOM top of memory 0xcc */
 198         pci_write_config16(PCI_DEV(0, 0x00, 0), TOM, cum);
 199         /* set TOLM top of low memory */
 200         if(cum > 0x18) {
 201                 cum = 0x18;
 202         }
 203         cum <<= 11;
 204         /* 0xc4 TOLM */
 205         pci_write_config16(PCI_DEV(0, 0x00, 0), TOLM, cum);
 206         return 0;
 207 }
 208
 209 static unsigned int spd_detect_dimms(const struct mem_controller *ctrl)
 210 {
 211         unsigned dimm_mask;
 212         int i;
 213         dimm_mask = 0;
 214         for(i = 0; i < DIMM_SOCKETS; i++) {
 215                 int byte;
 216                 unsigned device;
 217                 device = ctrl->channel0[i];
 218                 if (device) {
 219                         byte = spd_read_byte(device, 2);  /* Type */
 220                         if ((byte == 7) || (byte == 8)) {
 221                                 dimm_mask |= (1 << i);
 222                         }
 223                 }
 224                 device = ctrl->channel1[i];
 225                 if (device) {
 226                         byte = spd_read_byte(device, 2);
 227                         if ((byte == 7) || (byte == 8)) {
 228                                 dimm_mask |= (1 << (i + DIMM_SOCKETS));
 229                         }
 230                 }
 231         }
 232         return dimm_mask;
 233 }
 234
 235 static int spd_set_row_attributes(const struct mem_controller *ctrl,
 236                 long dimm_mask)
 237 {
 238
 239         int value;
 240         int reg;
 241         int dra;
 242         int cnt;
 243
 244         dra = 0;
 245         for(cnt=0; cnt < 4; cnt++) {
 246                 if (!(dimm_mask & (1 << cnt))) {
 247                         continue;
 248                 }
 249                 reg =0;
 250                 value = spd_read_byte(ctrl->channel0[cnt], 3);  /* rows */
 251                 if (value < 0) goto hw_err;
 252                 if ((value & 0xf) == 0) goto val_err;
 253                 reg += value & 0xf;
 254
 255                 value = spd_read_byte(ctrl->channel0[cnt], 4);  /* columns */
 256                 if (value < 0) goto hw_err;
 257                 if ((value & 0xf) == 0) goto val_err;
 258                 reg += value & 0xf;
 259
 260                 value = spd_read_byte(ctrl->channel0[cnt], 17); /* banks */
 261                 if (value < 0) goto hw_err;
 262                 if ((value & 0xff) == 0) goto val_err;
 263                 reg += log2(value & 0xff);
 264
 265                 /* Get the device width and convert it to a power of two */
 266                 value = spd_read_byte(ctrl->channel0[cnt], 13);
 267                 if (value < 0) goto hw_err;
 268                 value = log2(value & 0xff);
 269                 reg += value;
 270                 if(reg < 27) goto hw_err;
 271                 reg -= 27;
 272                 reg += (value << 2);
 273
 274                 dra += reg << (cnt*8);
 275                 value = spd_read_byte(ctrl->channel0[cnt], 5);
 276                 if (value & 2)
 277                         dra += reg << ((cnt*8)+4);
 278         }
 279
 280         /* 0x70 DRA */
 281         pci_write_config32(PCI_DEV(0, 0x00, 0), DRA, dra);
 282         goto out;
 283
 284  val_err:
 285         die("Bad SPD value\n");
 286         /* If an hw_error occurs report that I have no memory */
 287 hw_err:
 288         dra = 0;
 289 out:
 290         return dra;
 291
 292 }
 293
 294 static int spd_set_drt_attributes(const struct mem_controller *ctrl,
 295                 long dimm_mask, uint32_t drc)
 296 {
 297         int value;
 298         int reg;
 299         uint32_t drt;
 300         int cnt;
 301         int first_dimm;
 302         int cas_latency=0;
 303         int latency;
 304         uint32_t index = 0;
 305         uint32_t index2 = 0;
 306         static const unsigned char cycle_time[3] = {0x75,0x60,0x50};
 307         static const int latency_indicies[] = { 26, 23, 9 };
 308
 309         /* 0x78 DRT */
 310         drt = pci_read_config32(PCI_DEV(0, 0x00, 0), DRT);
 311         drt &= 3;  /* save bits 1:0 */
 312
 313         for(first_dimm = 0; first_dimm < 4; first_dimm++) {
 314                 if (dimm_mask & (1 << first_dimm))
 315                         break;
 316         }
 317
 318         /* get dimm type */
 319         value = spd_read_byte(ctrl->channel0[first_dimm], 2);
 320         if(value == 8) {
 321                 drt |= (3<<5); /* back to bark write turn around & cycle add */
 322         }
 323
 324         drt |= (3<<18);  /* Trasmax */
 325
 326         for(cnt=0; cnt < 4; cnt++) {
 327                 if (!(dimm_mask & (1 << cnt))) {
 328                         continue;
 329                 }
 330                 reg = spd_read_byte(ctrl->channel0[cnt], 18); /* CAS Latency */
 331                 /* Compute the lowest cas latency supported */
 332                 latency = log2(reg) -2;
 333
 334                 /* Loop through and find a fast clock with a low latency */
 335                 for(index = 0; index < 3; index++, latency++) {
 336                         if ((latency < 2) || (latency > 4) ||
 337                                 (!(reg & (1 << latency)))) {
 338                                 continue;
 339                         }
 340                         value = spd_read_byte(ctrl->channel0[cnt],
 341                                         latency_indicies[index]);
 342
 343                         if(value <= cycle_time[drc&3]) {
 344                                 if( latency > cas_latency) {
 345                                         cas_latency = latency;
 346                                 }
 347                                 break;
 348                         }
 349                 }
 350         }
 351         index = (cas_latency-2);
 352         if((index)==0) cas_latency = 20;
 353         else if((index)==1) cas_latency = 25;
 354         else cas_latency = 30;
 355
 356         for(cnt=0;cnt<4;cnt++) {
 357                 if (!(dimm_mask & (1 << cnt))) {
 358                         continue;
 359                 }
 360                 reg = spd_read_byte(ctrl->channel0[cnt], 27)&0x0ff;
 361                 if(((index>>8)&0x0ff)<reg) {
 362                         index &= ~(0x0ff << 8);
 363                         index |= (reg << 8);
 364                 }
 365                 reg = spd_read_byte(ctrl->channel0[cnt], 28)&0x0ff;
 366                 if(((index>>16)&0x0ff)<reg) {
 367                         index &= ~(0x0ff << 16);
 368                         index |= (reg<<16);
 369                 }
 370                 reg = spd_read_byte(ctrl->channel0[cnt], 29)&0x0ff;
 371                 if(((index2>>0)&0x0ff)<reg) {
 372                         index2 &= ~(0x0ff << 0);
 373                         index2 |= (reg<<0);
 374                 }
 375                 reg = spd_read_byte(ctrl->channel0[cnt], 41)&0x0ff;
 376                 if(((index2>>8)&0x0ff)<reg) {
 377                         index2 &= ~(0x0ff << 8);
 378                         index2 |= (reg<<8);
 379                 }
 380                 reg = spd_read_byte(ctrl->channel0[cnt], 42)&0x0ff;
 381                 if(((index2>>16)&0x0ff)<reg) {
 382                         index2 &= ~(0x0ff << 16);
 383                         index2 |= (reg<<16);
 384                 }
 385         }
 386
 387         /* get dimm speed */
 388         value = cycle_time[drc&3];
 389         if(value <= 0x50) {  /* 200 MHz */
 390                 if((index&7) > 2) {
 391                         drt |= (2<<2);  /* CAS latency 4 */
 392                         cas_latency = 40;
 393                 } else {
 394                         drt |= (1<<2);  /* CAS latency 3 */
 395                         cas_latency = 30;
 396                 }
 397                 if((index&0x0ff00)<=0x03c00) {
 398                         drt |= (1<<8);  /* Trp RAS Precharg */
 399                 } else {
 400                         drt |= (2<<8);  /* Trp RAS Precharg */
 401                 }
 402
 403                 /* Trcd RAS to CAS delay */
 404                 if((index2&0x0ff)<=0x03c) {
 405                         drt |= (0<<10);
 406                 } else {
 407                         drt |= (1<<10);
 408                 }
 409
 410                 /* Tdal Write auto precharge recovery delay */
 411                 drt |= (1<<12);
 412
 413                 /* Trc TRS min */
 414                 if((index2&0x0ff00)<=0x03700)
 415                         drt |= (0<<14);
 416                 else if((index2&0xff00)<=0x03c00)
 417                         drt |= (1<<14);
 418                 else
 419                         drt |= (2<<14); /* spd 41 */
 420
 421                 drt |= (2<<16);  /* Twr not defined for DDR docs say use 2 */
 422
 423                 /* Trrd Row Delay */
 424                 if((index&0x0ff0000)<=0x0140000) {
 425                         drt |= (0<<20);
 426                 } else if((index&0x0ff0000)<=0x0280000) {
 427                         drt |= (1<<20);
 428                 } else if((index&0x0ff0000)<=0x03c0000) {
 429                         drt |= (2<<20);
 430                 } else {
 431                         drt |= (3<<20);
 432                 }
 433
 434                 /* Trfc Auto refresh cycle time */
 435                 if((index2&0x0ff0000)<=0x04b0000) {
 436                         drt |= (0<<22);
 437                 } else if((index2&0x0ff0000)<=0x0690000) {
 438                         drt |= (1<<22);
 439                 } else {
 440                         drt |= (2<<22);
 441                 }
 442                 /* Docs say use 55 for all 200Mhz */
 443                 drt |= (0x055<<24);
 444         }
 445         else if(value <= 0x60) { /* 167 Mhz */
 446                 /* according to new documentation CAS latency is 00
 447                  * for bits 3:2 for all 167 Mhz
 448                 drt |= ((index&3)<<2); */  /* set CAS latency */
 449                 if((index&0x0ff00)<=0x03000) {
 450                         drt |= (1<<8);  /* Trp RAS Precharg */
 451                 } else {
 452                         drt |= (2<<8);  /* Trp RAS Precharg */
 453                 }
 454
 455                 /* Trcd RAS to CAS delay */
 456                 if((index2&0x0ff)<=0x030) {
 457                         drt |= (0<<10);
 458                 } else {
 459                         drt |= (1<<10);
 460                 }
 461
 462                 /* Tdal Write auto precharge recovery delay */
 463                 drt |= (2<<12);
 464
 465                 /* Trc TRS min */
 466                 drt |= (2<<14); /* spd 41, but only one choice */
 467
 468                 drt |= (2<<16);  /* Twr not defined for DDR docs say 2 */
 469
 470                 /* Trrd Row Delay */
 471                 if((index&0x0ff0000)<=0x0180000) {
 472                         drt |= (0<<20);
 473                 } else if((index&0x0ff0000)<=0x0300000) {
 474                         drt |= (1<<20);
 475                 } else {
 476                         drt |= (2<<20);
 477                 }
 478
 479                 /* Trfc Auto refresh cycle time */
 480                 if((index2&0x0ff0000)<=0x0480000) {
 481                         drt |= (0<<22);
 482                 } else if((index2&0x0ff0000)<=0x0780000) {
 483                         drt |= (2<<22);
 484                 } else {
 485                         drt |= (2<<22);
 486                 }
 487                 /* Docs state to use 99 for all 167 Mhz */
 488                 drt |= (0x099<<24);
 489         }
 490         else if(value <= 0x75) { /* 133 Mhz */
 491                 drt |= ((index&3)<<2);  /* set CAS latency */
 492                 if((index&0x0ff00)<=0x03c00) {
 493                         drt |= (1<<8);  /* Trp RAS Precharg */
 494                 } else {
 495                         drt |= (2<<8);  /* Trp RAS Precharg */
 496                 }
 497
 498                 /* Trcd RAS to CAS delay */
 499                 if((index2&0x0ff)<=0x03c) {
 500                         drt |= (0<<10);
 501                 } else {
 502                         drt |= (1<<10);
 503                 }
 504
 505                 /* Tdal Write auto precharge recovery delay */
 506                 drt |= (1<<12);
 507
 508                 /* Trc TRS min */
 509                 drt |= (2<<14); /* spd 41, but only one choice */
 510
 511                 drt |= (1<<16);  /* Twr not defined for DDR docs say 1 */
 512
 513                 /* Trrd Row Delay */
 514                 if((index&0x0ff0000)<=0x01e0000) {
 515                         drt |= (0<<20);
 516                 } else if((index&0x0ff0000)<=0x03c0000) {
 517                         drt |= (1<<20);
 518                 } else {
 519                         drt |= (2<<20);
 520                 }
 521
 522                 /* Trfc Auto refresh cycle time */
 523                 if((index2&0x0ff0000)<=0x04b0000) {
 524                         drt |= (0<<22);
 525                 } else if((index2&0x0ff0000)<=0x0780000) {
 526                         drt |= (2<<22);
 527                 } else {
 528                         drt |= (2<<22);
 529                 }
 530
 531                 /* Based on CAS latency */
 532                 if(index&7)
 533                         drt |= (0x099<<24);
 534                 else
 535                         drt |= (0x055<<24);
 536
 537         }
 538         else {
 539                 die("Invalid SPD 9 bus speed.\n");
 540         }
 541
 542         /* 0x78 DRT */
 543         pci_write_config32(PCI_DEV(0, 0x00, 0), DRT, drt);
 544
 545         return(cas_latency);
 546 }
 547
 548 static int spd_set_dram_controller_mode(const struct mem_controller *ctrl,
 549                 long dimm_mask)
 550 {
 551         int value;
 552         int reg;
 553         int drc;
 554         int cnt;
 555         msr_t msr;
 556         unsigned char dram_type = 0xff;
 557         unsigned char ecc = 0xff;
 558         unsigned char rate = 62;
 559         static const unsigned char spd_rates[6] = {15,3,7,7,62,62};
 560         static const unsigned char drc_rates[5] = {0,15,7,62,3};
 561         static const unsigned char fsb_conversion[4] = {3,1,3,2};
 562
 563         /* 0x7c DRC */
 564         drc = pci_read_config32(PCI_DEV(0, 0x00, 0), DRC);
 565         for(cnt=0; cnt < 4; cnt++) {
 566                 if (!(dimm_mask & (1 << cnt))) {
 567                         continue;
 568                 }
 569                 value = spd_read_byte(ctrl->channel0[cnt], 11); /* ECC */
 570                 reg = spd_read_byte(ctrl->channel0[cnt], 2); /* Type */
 571                 if (value == 2) {    /* RAM is ECC capable */
 572                         if (reg == 8) {
 573                                 if ( ecc == 0xff ) {
 574                                         ecc = 2;
 575                                 }
 576                                 else if (ecc == 1) {
 577                                         die("ERROR - Mixed DDR & DDR2 RAM\n");
 578                                 }
 579                         }
 580                         else if ( reg == 7 ) {
 581                                 if ( ecc == 0xff) {
 582                                         ecc = 1;
 583                                 }
 584                                 else if ( ecc > 1 ) {
 585                                         die("ERROR - Mixed DDR & DDR2 RAM\n");
 586                                 }
 587                         }
 588                         else {
 589                                 die("ERROR - RAM not DDR\n");
 590                         }
 591                 }
 592                 else {
 593                         die("ERROR - Non ECC memory dimm\n");
 594                 }
 595
 596                 value = spd_read_byte(ctrl->channel0[cnt], 12); /*refresh rate*/
 597                 value &= 0x0f;    /* clip self refresh bit */
 598                 if (value > 5) goto hw_err;
 599                 if (rate > spd_rates[value])
 600                         rate = spd_rates[value];
 601
 602                 value = spd_read_byte(ctrl->channel0[cnt], 9);  /* cycle time */
 603                 if (value > 0x75) goto hw_err;
 604                 if (value <= 0x50) {
 605                         if (dram_type >= 2) {
 606                                 if (reg == 8) { /*speed is good, is this ddr2?*/
 607                                         dram_type = 2;
 608                                 } else { /* not ddr2 so use ddr333 */
 609                                         dram_type = 1;
 610                                 }
 611                         }
 612                 }
 613                 else if (value <= 0x60) {
 614                         if (dram_type >= 1)  dram_type = 1;
 615                 }
 616                 else dram_type = 0; /* ddr266 */
 617
 618         }
 619         ecc = 2;
 620 #if CONFIG_HAVE_OPTION_TABLE
 621         if (read_option(ECC_memory, 1) == 0) {
 622                 ecc = 0;  /* ECC off in CMOS so disable it */
 623                 print_debug("ECC off\n");
 624         } else
 625 #endif
 626         {
 627                 print_debug("ECC on\n");
 628         }
 629         drc &= ~(3 << 20); /* clear the ecc bits */
 630         drc |= (ecc << 20);  /* or in the calculated ecc bits */
 631         for ( cnt = 1; cnt < 5; cnt++)
 632                 if (drc_rates[cnt] == rate)
 633                         break;
 634         if (cnt < 5) {
 635                 drc &= ~(7 << 8);  /* clear the rate bits */
 636                 drc |= (cnt << 8);
 637         }
 638
 639         if (reg == 8) { /* independant clocks */
 640                 drc |= (1 << 4);
 641         }
 642
 643         drc |= (1 << 26); /* set the overlap bit - the factory BIOS does */
 644         drc |= (1 << 27); /* set DED retry enable - the factory BIOS does */
 645         /* front side bus */
 646         msr = rdmsr(0x2c);
 647         value = msr.lo >> 16;
 648         value &= 0x03;
 649         drc &= ~(3 << 2); /* set the front side bus */
 650         drc |= (fsb_conversion[value] << 2);
 651         drc &= ~(3 << 0); /* set the dram type */
 652         drc |= (dram_type << 0);
 653
 654         goto out;
 655
 656  val_err:
 657         die("Bad SPD value\n");
 658         /* If an hw_error occurs report that I have no memory */
 659 hw_err:
 660         drc = 0;
 661 out:
 662         return drc;
 663 }
 664
 665 static void sdram_set_spd_registers(const struct mem_controller *ctrl)
 666 {
 667         long dimm_mask;
 668
 669         /* Test if we can read the spd and if ram is ddr or ddr2 */
 670         dimm_mask = spd_detect_dimms(ctrl);
 671         if (!(dimm_mask & ((1 << DIMM_SOCKETS) - 1))) {
 672                 print_err("No memory for this cpu\n");
 673                 return;
 674         }
 675         return;
 676 }
 677
 678 static void do_delay(void)
 679 {
 680         int i;
 681         unsigned char b;
 682         for(i=0;i<16;i++)
 683                 b=inb(0x80);
 684 }
 685
 686 static void pll_setup(uint32_t drc)
 687 {
 688         unsigned pins;
 689         if(drc&3) { /* DDR 333 or DDR 400 */
 690                 if((drc&0x0c) == 0x0c) { /* FSB 200 */
 691                         pins = 2 | 1;
 692                 }
 693                 else if((drc&0x0c) == 0x08) {   /* FSB 167 */
 694                         pins = 0 | 1;
 695                 }
 696                 else if(drc&1){  /* FSB 133 DDR 333 */
 697                         pins = 2 | 1;
 698                 }
 699                 else { /* FSB 133 DDR 400 */
 700                         pins = 0 | 1;
 701                 }
 702         }
 703         else { /* DDR 266 */
 704                 if((drc&0x08) == 0x08) { /* FSB 200 or 167 */
 705                         pins = 0 | 0;
 706                 }
 707                 else { /* FSB 133 */
 708                         pins = 0 | 1;
 709                 }
 710         }
 711         mainboard_set_e7520_pll(pins);
 712         return;
 713 }
 714
 715 #define TIMEOUT_LOOPS 300000
 716
 717 #define DCALCSR  0x100
 718 #define DCALADDR 0x104
 719 #define DCALDATA 0x108
 720
 721 static void set_on_dimm_termination_enable(const struct mem_controller *ctrl)
 722 {
 723         unsigned char c1,c2;
 724         unsigned int dimm,i;
 725         unsigned int data32;
 726         unsigned int t4;
 727
 728         /* Set up northbridge values */
 729         /* ODT enable */
 730         pci_write_config32(PCI_DEV(0, 0x00, 0), 0x88, 0xf0000180);
 731         /* Figure out which slots are Empty, Single, or Double sided */
 732         for(i=0,t4=0,c2=0;i<8;i+=2) {
 733                 c1 = pci_read_config8(PCI_DEV(0, 0x00, 0), DRB+i);
 734                 if(c1 == c2) continue;
 735                 c2 = pci_read_config8(PCI_DEV(0, 0x00, 0), DRB+1+i);
 736                 if(c1 == c2)
 737                         t4 |= (1 << (i*4));
 738                 else
 739                         t4 |= (2 << (i*4));
 740         }
 741         for(i=0;i<1;i++) {
 742             if((t4&0x0f) == 1) {
 743                 if( ((t4>>8)&0x0f) == 0 ) {
 744                         data32 = 0x00000010; /* EEES */
 745                         break;
 746                 }
 747                 if ( ((t4>>16)&0x0f) == 0 ) {
 748                         data32 = 0x00003132; /* EESS */
 749                         break;
 750                 }
 751                 if ( ((t4>>24)&0x0f)  == 0 ) {
 752                         data32 = 0x00335566; /* ESSS */
 753                         break;
 754                 }
 755                 data32 = 0x77bbddee; /* SSSS */
 756                 break;
 757             }
 758             if((t4&0x0f) == 2) {
 759                 if( ((t4>>8)&0x0f) == 0 ) {
 760                         data32 = 0x00003132; /* EEED */
 761                         break;
 762                 }
 763                 if ( ((t4>>8)&0x0f) == 2 ) {
 764                         data32 = 0xb373ecdc; /* EEDD */
 765                         break;
 766                 }
 767                 if ( ((t4>>16)&0x0f) == 0 ) {
 768                         data32 = 0x00b3a898; /* EESD */
 769                         break;
 770                 }
 771                 data32 = 0x777becdc; /* ESSD */
 772                 break;
 773             }
 774             die("Error - First dimm slot empty\n");
 775         }
 776
 777         print_debug("ODT Value = ");
 778         print_debug_hex32(data32);
 779         print_debug("\n");
 780
 781         pci_write_config32(PCI_DEV(0, 0x00, 0), 0xb0, data32);
 782
 783         for(dimm=0;dimm<8;dimm+=1) {
 784
 785                 write32(BAR+DCALADDR, 0x0b840001);
 786                 write32(BAR+DCALCSR, 0x83000003 | (dimm << 20));
 787
 788                 for(i=0;i<1001;i++) {
 789                         data32 = read32(BAR+DCALCSR);
 790                         if(!(data32 & (1<<31)))
 791                                 break;
 792                 }
 793         }
 794 }
 795
 796 static void set_receive_enable(const struct mem_controller *ctrl)
 797 {
 798         unsigned int i;
 799         unsigned int cnt;
 800         uint32_t recena=0;
 801         uint32_t recenb=0;
 802
 803         {
 804         unsigned int dimm;
 805         unsigned int edge;
 806         int32_t data32;
 807         uint32_t data32_dram;
 808         uint32_t dcal_data32_0;
 809         uint32_t dcal_data32_1;
 810         uint32_t dcal_data32_2;
 811         uint32_t dcal_data32_3;
 812         uint32_t work32l;
 813         uint32_t work32h;
 814         uint32_t data32r;
 815         int32_t recen;
 816         for(dimm=0;dimm<8;dimm+=1) {
 817
 818                 if(!(dimm&1)) {
 819                         write32(BAR+DCALDATA+(17*4), 0x04020000);
 820                         write32(BAR+DCALCSR, 0x83800004 | (dimm << 20));
 821
 822                         for(i=0;i<1001;i++) {
 823                                 data32 = read32(BAR+DCALCSR);
 824                                 if(!(data32 & (1<<31)))
 825                                         break;
 826                         }
 827                         if(i>=1000)
 828                                 continue;
 829
 830                         dcal_data32_0 = read32(BAR+DCALDATA + 0);
 831                         dcal_data32_1 = read32(BAR+DCALDATA + 4);
 832                         dcal_data32_2 = read32(BAR+DCALDATA + 8);
 833                         dcal_data32_3 = read32(BAR+DCALDATA + 12);
 834                 }
 835                 else {
 836                         dcal_data32_0 = read32(BAR+DCALDATA + 16);
 837                         dcal_data32_1 = read32(BAR+DCALDATA + 20);
 838                         dcal_data32_2 = read32(BAR+DCALDATA + 24);
 839                         dcal_data32_3 = read32(BAR+DCALDATA + 28);
 840                 }
 841
 842                 /* check if bank is installed */
 843                 if((dcal_data32_0 == 0) && (dcal_data32_2 == 0))
 844                         continue;
 845                 /* Calculate the timing value */
 846                 {
 847                 unsigned int bit;
 848                 for(i=0,edge=0,bit=63,cnt=31,data32r=0,
 849                         work32l=dcal_data32_1,work32h=dcal_data32_3;
 850                                 (i<4) && bit; i++) {
 851                         for(;;bit--,cnt--) {
 852                                 if(work32l & (1<<cnt))
 853                                         break;
 854                                 if(!cnt) {
 855                                         work32l = dcal_data32_0;
 856                                         work32h = dcal_data32_2;
 857                                         cnt = 32;
 858                                 }
 859                                 if(!bit) break;
 860                         }
 861                         for(;;bit--,cnt--) {
 862                                 if(!(work32l & (1<<cnt)))
 863                                         break;
 864                                 if(!cnt) {
 865                                         work32l = dcal_data32_0;
 866                                         work32h = dcal_data32_2;
 867                                         cnt = 32;
 868                                 }
 869                                 if(!bit) break;
 870                         }
 871                         if(!bit) {
 872                                 break;
 873                         }
 874                         data32 = ((bit%8) << 1);
 875                         if(work32h & (1<<cnt))
 876                                 data32 += 1;
 877                         if(data32 < 4) {
 878                                 if(!edge) {
 879                                         edge = 1;
 880                                 }
 881                                 else {
 882                                         if(edge != 1) {
 883                                                 data32 = 0x0f;
 884                                         }
 885                                 }
 886                         }
 887                         if(data32 > 12) {
 888                                 if(!edge) {
 889                                         edge = 2;
 890                                 }
 891                                 else {
 892                                         if(edge != 2) {
 893                                                 data32 = 0x00;
 894                                         }
 895                                 }
 896                         }
 897                         data32r += data32;
 898                 }
 899                 }
 900                 work32l = dcal_data32_0;
 901                 work32h = dcal_data32_2;
 902                 recen = data32r;
 903                 recen += 3;
 904                 recen = recen>>2;
 905                 for(cnt=5;cnt<24;) {
 906                         for(;;cnt++)
 907                                 if(!(work32l & (1<<cnt)))
 908                                         break;
 909                         for(;;cnt++) {
 910                                 if(work32l & (1<<cnt))
 911                                         break;
 912                         }
 913                         data32 = (((cnt-1)%8)<<1);
 914                         if(work32h & (1<<(cnt-1))) {
 915                                 data32++;
 916                         }
 917                         /* test for frame edge cross overs */
 918                         if((edge == 1) && (data32 > 12) &&
 919                             (((recen+16)-data32) < 3)) {
 920                                 data32 = 0;
 921                                 cnt += 2;
 922                         }
 923                         if((edge == 2) && (data32 < 4) &&
 924                             ((recen - data32) > 12))  {
 925                                 data32 = 0x0f;
 926                                 cnt -= 2;
 927                         }
 928                         if(((recen+3) >= data32) && ((recen-3) <= data32))
 929                                 break;
 930                 }
 931                 cnt--;
 932                 cnt /= 8;
 933                 cnt--;
 934                 if(recen&1)
 935                         recen+=2;
 936                 recen >>= 1;
 937                 recen += (cnt*8);
 938                 recen+=2;      /* this is not in the spec, but matches
 939                                  the factory output, and has less failure */
 940                 recen <<= (dimm/2) * 8;
 941                 if(!(dimm&1)) {
 942                         recena |= recen;
 943                 }
 944                 else {
 945                         recenb |= recen;
 946                 }
 947         }
 948         }
 949         /* Check for Eratta problem */
 950         for(i=cnt=0;i<32;i+=8) {
 951                 if (((recena>>i)&0x0f)>7) {
 952                         cnt+= 0x101;
 953                 }
 954                 else {
 955                         if((recena>>i)&0x0f) {
 956                                 cnt++;
 957                         }
 958                 }
 959         }
 960         if(cnt&0x0f00) {
 961                 cnt = (cnt&0x0f) - (cnt>>16);
 962                 if(cnt>1) {
 963                         for(i=0;i<32;i+=8) {
 964                                 if(((recena>>i)&0x0f)>7) {
 965                                         recena &= ~(0x0f<<i);
 966                                         recena |= (7<<i);
 967                                 }
 968                         }
 969                 }
 970                 else {
 971                         for(i=0;i<32;i+=8) {
 972                                 if(((recena>>i)&0x0f)<8) {
 973                                         recena &= ~(0x0f<<i);
 974                                         recena |= (8<<i);
 975                                 }
 976                         }
 977                 }
 978         }
 979         for(i=cnt=0;i<32;i+=8) {
 980                 if (((recenb>>i)&0x0f)>7) {
 981                         cnt+= 0x101;
 982                 }
 983                 else {
 984                         if((recenb>>i)&0x0f) {
 985                                 cnt++;
 986                         }
 987                 }
 988         }
 989         if(cnt & 0x0f00) {
 990                 cnt = (cnt&0x0f) - (cnt>>16);
 991                 if(cnt>1) {
 992                         for(i=0;i<32;i+=8) {
 993                                 if(((recenb>>i)&0x0f)>7) {
 994                                         recenb &= ~(0x0f<<i);
 995                                         recenb |= (7<<i);
 996                                 }
 997                         }
 998                 }
 999                 else {
1000                         for(i=0;i<32;i+=8) {
1001                                 if(((recenb>>8)&0x0f)<8) {
1002                                         recenb &= ~(0x0f<<i);
1003                                         recenb |= (8<<i);
1004                                 }
1005                         }
1006                 }
1007         }
1008
1009         print_debug("Receive enable A = ");
1010         print_debug_hex32(recena);
1011         print_debug(",  Receive enable B = ");
1012         print_debug_hex32(recenb);
1013         print_debug("\n");
1014
1015         /* clear out the calibration area */
1016         write32(BAR+DCALDATA+(16*4), 0x00000000);
1017         write32(BAR+DCALDATA+(17*4), 0x00000000);
1018         write32(BAR+DCALDATA+(18*4), 0x00000000);
1019         write32(BAR+DCALDATA+(19*4), 0x00000000);
1020
1021         /* No command */
1022         write32(BAR+DCALCSR, 0x0000000f);
1023
1024         write32(BAR+0x150, recena);
1025         write32(BAR+0x154, recenb);
1026 }
1027
1028 static void sdram_enable(int controllers, const struct mem_controller *ctrl)
1029 {
1030         int i;
1031         int cs;
1032         int cnt;
1033         int cas_latency;
1034         long mask;
1035         uint32_t drc;
1036         uint32_t data32;
1037         uint32_t mode_reg;
1038         uint32_t *iptr;
1039         volatile unsigned long *iptrv;
1040         msr_t msr;
1041         uint32_t scratch;
1042         uint8_t byte;
1043         uint16_t data16;
1044         static const struct {
1045                 uint32_t clkgr[4];
1046         } gearing [] = {
1047                 /* FSB 133 DIMM 266 */
1048         {{ 0x00000001, 0x00000000, 0x00000001, 0x00000000}},
1049                 /* FSB 133 DIMM 333 */
1050         {{ 0x00000000, 0x00000000, 0x00000000, 0x00000000}},
1051                 /* FSB 133 DIMM 400 */
1052         {{ 0x00000120, 0x00000000, 0x00000032, 0x00000010}},
1053                 /* FSB 167 DIMM 266 */
1054         {{ 0x00005432, 0x00001000, 0x00004325, 0x00000000}},
1055                 /* FSB 167 DIMM 333 */
1056         {{ 0x00000001, 0x00000000, 0x00000001, 0x00000000}},
1057                 /* FSB 167 DIMM 400 */
1058         {{ 0x00154320, 0x00000000, 0x00065432, 0x00010000}},
1059                 /* FSB 200 DIMM 266 */
1060         {{ 0x00000032, 0x00000010, 0x00000120, 0x00000000}},
1061                 /* FSB 200 DIMM 333 */
1062         {{ 0x00065432, 0x00010000, 0x00154320, 0x00000000}},
1063                 /* FSB 200 DIMM 400 */
1064         {{ 0x00000001, 0x00000000, 0x00000001, 0x00000000}},
1065         };
1066
1067         static const uint32_t dqs_data[] = {
1068                 0xffffffff, 0xffffffff, 0x000000ff,
1069                 0xffffffff, 0xffffffff, 0x000000ff,
1070                 0xffffffff, 0xffffffff, 0x000000ff,
1071                 0xffffffff, 0xffffffff, 0x000000ff,
1072                 0xffffffff, 0xffffffff, 0x000000ff,
1073                 0xffffffff, 0xffffffff, 0x000000ff,
1074                 0xffffffff, 0xffffffff, 0x000000ff,
1075                 0xffffffff, 0xffffffff, 0x000000ff};
1076
1077         mask = spd_detect_dimms(ctrl);
1078         print_debug("Starting SDRAM Enable\n");
1079
1080         /* 0x80 */
1081         pci_write_config32(PCI_DEV(0, 0x00, 0), DRM,
1082                 0x00210000 | CONFIG_DIMM_MAP_LOGICAL);
1083         /* set dram type and Front Side Bus freq. */
1084         drc = spd_set_dram_controller_mode(ctrl, mask);
1085         if( drc == 0) {
1086                 die("Error calculating DRC\n");
1087         }
1088         pll_setup(drc);
1089         data32 = drc & ~(3 << 20);  /* clear ECC mode */
1090         data32 = data32 & ~(7 << 8);  /* clear refresh rates */
1091         data32 = data32 | (1 << 5);  /* temp turn off of ODT */
1092         /* Set gearing, then dram controller mode */
1093         /* drc bits 1:0 = DIMM speed, bits 3:2 = FSB speed */
1094         for(iptr = gearing[(drc&3)+((((drc>>2)&3)-1)*3)].clkgr,cnt=0;
1095                         cnt<4;cnt++) {
1096                 pci_write_config32(PCI_DEV(0, 0x00, 0), 0xa0+(cnt*4), iptr[cnt]);
1097         }
1098         /* 0x7c DRC */
1099         pci_write_config32(PCI_DEV(0, 0x00, 0), DRC, data32);
1100
1101                 /* turn the clocks on */
1102         /* 0x8c CKDIS */
1103         pci_write_config16(PCI_DEV(0, 0x00, 0), CKDIS, 0x0000);
1104
1105                 /* 0x9a DDRCSR Take subsystem out of idle */
1106         data16 = pci_read_config16(PCI_DEV(0, 0x00, 0), DDRCSR);
1107         data16 &= ~(7 << 12);
1108         data16 |= (3 << 12);   /* use dual channel lock step */
1109         pci_write_config16(PCI_DEV(0, 0x00, 0), DDRCSR, data16);
1110
1111                 /* program row size DRB */
1112         spd_set_ram_size(ctrl, mask);
1113
1114                 /* program page size DRA */
1115         spd_set_row_attributes(ctrl, mask);
1116
1117                 /* program DRT timing values */
1118         cas_latency = spd_set_drt_attributes(ctrl, mask, drc);
1119
1120         for(i=0;i<8;i++) { /* loop throught each dimm to test for row */
1121                 print_debug("DIMM ");
1122                 print_debug_hex8(i);
1123                 print_debug("\n");
1124                 /* Apply NOP */
1125                 do_delay();
1126
1127                 write32(BAR + 0x100, (0x03000000 | (i<<20)));
1128
1129                 write32(BAR+0x100, (0x83000000 | (i<<20)));
1130
1131                 do data32 = read32(BAR+DCALCSR);
1132                 while(data32 & 0x80000000);
1133
1134         }
1135
1136         /* Apply NOP */
1137         do_delay();
1138
1139         for(cs=0;cs<8;cs++) {
1140                 write32(BAR + DCALCSR, (0x83000000 | (cs<<20)));
1141                 do data32 = read32(BAR+DCALCSR);
1142                 while(data32 & 0x80000000);
1143         }
1144
1145         /* Precharg all banks */
1146         do_delay();
1147         for(cs=0;cs<8;cs++) {
1148                 if ((drc & 3) == 2) /* DDR2  */
1149                         write32(BAR+DCALADDR, 0x04000000);
1150                 else   /* DDR1  */
1151                         write32(BAR+DCALADDR, 0x00000000);
1152                 write32(BAR+DCALCSR, (0x83000002 | (cs<<20)));
1153                 do data32 = read32(BAR+DCALCSR);
1154                 while(data32 & 0x80000000);
1155         }
1156
1157         /* EMRS dll's enabled */
1158         do_delay();
1159         for(cs=0;cs<8;cs++) {
1160                 if ((drc & 3) == 2) /* DDR2  */
1161                         /* fixme hard code AL additive latency */
1162                         write32(BAR+DCALADDR, 0x0b940001);
1163                 else   /* DDR1  */
1164                         write32(BAR+DCALADDR, 0x00000001);
1165                 write32(BAR+DCALCSR, (0x83000003 | (cs<<20)));
1166                 do data32 = read32(BAR+DCALCSR);
1167                 while(data32 & 0x80000000);
1168         }
1169         /* MRS reset dll's */
1170         do_delay();
1171         if ((drc & 3) == 2) {  /* DDR2  */
1172                 if(cas_latency == 30)
1173                         mode_reg = 0x053a0000;
1174                 else
1175                         mode_reg = 0x054a0000;
1176         }
1177         else {  /* DDR1  */
1178                 if(cas_latency == 20)
1179                         mode_reg = 0x012a0000;
1180                 else  /*  CAS Latency 2.5 */
1181                         mode_reg = 0x016a0000;
1182         }
1183         for(cs=0;cs<8;cs++) {
1184                 write32(BAR+DCALADDR, mode_reg);
1185                 write32(BAR+DCALCSR, (0x83000003 | (cs<<20)));
1186                 do data32 = read32(BAR+DCALCSR);
1187                 while(data32 & 0x80000000);
1188         }
1189
1190         /* Precharg all banks */
1191         do_delay();
1192         do_delay();
1193         do_delay();
1194         for(cs=0;cs<8;cs++) {
1195                 if ((drc & 3) == 2) /* DDR2  */
1196                         write32(BAR+DCALADDR, 0x04000000);
1197                 else   /* DDR1  */
1198                         write32(BAR+DCALADDR, 0x00000000);
1199                 write32(BAR+DCALCSR, (0x83000002 | (cs<<20)));
1200                 do data32 = read32(BAR+DCALCSR);
1201                 while(data32 & 0x80000000);
1202         }
1203
1204         /* Do 2 refreshes */
1205         do_delay();
1206         for(cs=0;cs<8;cs++) {
1207                 write32(BAR+DCALCSR, (0x83000001 | (cs<<20)));
1208                 do data32 = read32(BAR+DCALCSR);
1209                 while(data32 & 0x80000000);
1210         }
1211         do_delay();
1212         for(cs=0;cs<8;cs++) {
1213                 write32(BAR+DCALCSR, (0x83000001 | (cs<<20)));
1214                 do data32 = read32(BAR+DCALCSR);
1215                 while(data32 & 0x80000000);
1216         }
1217         do_delay();
1218         /* for good luck do 6 more */
1219         for(cs=0;cs<8;cs++) {
1220                 write32(BAR+DCALCSR, (0x83000001 | (cs<<20)));
1221         }
1222         do_delay();
1223         for(cs=0;cs<8;cs++) {
1224                 write32(BAR+DCALCSR, (0x83000001 | (cs<<20)));
1225         }
1226         do_delay();
1227         for(cs=0;cs<8;cs++) {
1228                 write32(BAR+DCALCSR, (0x83000001 | (cs<<20)));
1229         }
1230         do_delay();
1231         for(cs=0;cs<8;cs++) {
1232                 write32(BAR+DCALCSR, (0x83000001 | (cs<<20)));
1233         }
1234         do_delay();
1235         for(cs=0;cs<8;cs++) {
1236                 write32(BAR+DCALCSR, (0x83000001 | (cs<<20)));
1237         }
1238         do_delay();
1239         for(cs=0;cs<8;cs++) {
1240                 write32(BAR+DCALCSR, (0x83000001 | (cs<<20)));
1241         }
1242         do_delay();
1243         /* MRS reset dll's normal */
1244         do_delay();
1245         for(cs=0;cs<8;cs++) {
1246                 write32(BAR+DCALADDR, (mode_reg & ~(1<<24)));
1247                 write32(BAR+DCALCSR, (0x83000003 | (cs<<20)));
1248                 do data32 = read32(BAR+DCALCSR);
1249                 while(data32 & 0x80000000);
1250         }
1251
1252         /* Do only if DDR2  EMRS dll's enabled */
1253         if ((drc & 3) == 2) { /* DDR2  */
1254                 do_delay();
1255                 for(cs=0;cs<8;cs++) {
1256                         write32(BAR+DCALADDR, (0x0b940001));
1257                         write32(BAR+DCALCSR, (0x83000003 | (cs<<20)));
1258                         do data32 = read32(BAR+DCALCSR);
1259                         while(data32 & 0x80000000);
1260                 }
1261         }
1262
1263         do_delay();
1264         /* No command */
1265         write32(BAR+DCALCSR, 0x0000000f);
1266
1267         /* DDR1 This is test code to copy some codes in the factory setup */
1268
1269         write32(BAR, 0x00100000);
1270
1271         if ((drc & 3) == 2) { /* DDR2  */
1272         /* enable on dimm termination */
1273                 set_on_dimm_termination_enable(ctrl);
1274         }
1275         else { /* ddr */
1276                 pci_write_config32(PCI_DEV(0, 0x00, 0), 0x88, 0xa0000000 );
1277         }
1278
1279         /* receive enable calibration */
1280         set_receive_enable(ctrl);
1281
1282         /* DQS */
1283         pci_write_config32(PCI_DEV(0, 0x00, 0), 0x94, 0x3904a100 );
1284         for(i = 0, cnt = (BAR+0x200); i < 24; i++, cnt+=4) {
1285                 write32(cnt, dqs_data[i]);
1286         }
1287         pci_write_config32(PCI_DEV(0, 0x00, 0), 0x94, 0x3904a100 );
1288
1289         /* Enable refresh */
1290         /* 0x7c DRC */
1291         data32 = drc & ~(3 << 20);  /* clear ECC mode */
1292         pci_write_config32(PCI_DEV(0, 0x00, 0), DRC, data32);
1293         write32(BAR+DCALCSR, 0x0008000f);
1294
1295         /* clear memory and init ECC */
1296         print_debug("Clearing memory\n");
1297         for(i=0;i<64;i+=4) {
1298                 write32(BAR+DCALDATA+i, 0x00000000);
1299         }
1300
1301         for(cs=0;cs<8;cs++) {
1302                 write32(BAR+DCALCSR, (0x830831d8 | (cs<<20)));
1303                 do data32 = read32(BAR+DCALCSR);
1304                 while(data32 & 0x80000000);
1305         }
1306
1307         /* Bring memory subsystem on line */
1308         data32 = pci_read_config32(PCI_DEV(0, 0x00, 0), 0x98);
1309         data32 |= (1 << 31);
1310         pci_write_config32(PCI_DEV(0, 0x00, 0), 0x98, data32);
1311         /* wait for completion */
1312         print_debug("Waiting for mem complete\n");
1313         while(1) {
1314                 data32 = pci_read_config32(PCI_DEV(0, 0x00, 0), 0x98);
1315                 if( (data32 & (1<<31)) == 0)
1316                         break;
1317         }
1318         print_debug("Done\n");
1319
1320         /* Set initialization complete */
1321         /* 0x7c DRC */
1322         drc |= (1 << 29);
1323         data32 = drc & ~(3 << 20);  /* clear ECC mode */
1324         pci_write_config32(PCI_DEV(0, 0x00, 0), DRC, data32);
1325
1326         /* Set the ecc mode */
1327         pci_write_config32(PCI_DEV(0, 0x00, 0), DRC, drc);
1328
1329         /* Enable memory scrubbing */
1330         /* 0x52 MCHSCRB */
1331         data16 = pci_read_config16(PCI_DEV(0, 0x00, 0), MCHSCRB);
1332         data16 &= ~0x0f;
1333         data16 |= ((2 << 2) | (2 << 0));
1334         pci_write_config16(PCI_DEV(0, 0x00, 0), MCHSCRB, data16);
1335
1336         /* The memory is now setup, use it */
1337         cache_lbmem(MTRR_TYPE_WRBACK);
1338 }