src/northbridge/via/vt8601/raminit.c

   1 #include <cpu/x86/mtrr.h>
   2 #include "raminit.h"
   3
   4 /*
   5 This software and ancillary information (herein called SOFTWARE )
   6 called LinuxBIOS          is made available under the terms described
   7 here.  The SOFTWARE has been approved for release with associated
   8 LA-CC Number 00-34   .  Unless otherwise indicated, this SOFTWARE has
   9 been authored by an employee or employees of the University of
  10 California, operator of the Los Alamos National Laboratory under
  11 Contract No. W-7405-ENG-36 with the U.S. Department of Energy.  The
  12 U.S. Government has rights to use, reproduce, and distribute this
  13 SOFTWARE.  The public may copy, distribute, prepare derivative works
  14 and publicly display this SOFTWARE without charge, provided that this
  15 Notice and any statement of authorship are reproduced on all copies.
  16 Neither the Government nor the University makes any warranty, express
  17 or implied, or assumes any liability or responsibility for the use of
  18 this SOFTWARE.  If SOFTWARE is modified to produce derivative works,
  19 such modified SOFTWARE should be clearly marked, so as not to confuse
  20 it with the version available from LANL.
  21  */
  22 /* Copyright 2000, Ron Minnich, Advanced Computing Lab, LANL
  23  * rminnich@lanl.gov
  24  */
  25 /*
  26  * 11/26/02 - kevinh@ispiri.com - The existing comments implied that
  27  * this didn't work yet.  Therefore, I've updated it so that it works
  28  * correctly - at least on my VIA epia motherboard.  64MB DIMM in slot 0.
  29  */
  30
  31 /* Added automatic detection of first equipped bank and its MA mapping type.
  32  * (Rest of configuration is done in C)
  33  * 5/19/03 by SONE Takeshi <ts1@tsn.or.jp>
  34  */
  35 /* converted to C 9/2003 Ron Minnich */
  36
  37 /* Set to 1 if your DIMMs are PC133 Note that I'm assuming CPU's FSB
  38  * frequency is 133MHz. If your CPU runs at another bus speed, you
  39  * might need to change some of register values.
  40  */
  41 #ifndef DIMM_PC133
  42 #define DIMM_PC133 0
  43 #endif
  44
  45 // Set to 1 if your DIMMs are CL=2
  46 #ifndef DIMM_CL2
  47 #define DIMM_CL2 0
  48 #endif
  49
  50 void dimms_read(unsigned long x)
  51 {
  52         uint8_t c;
  53         unsigned long eax;
  54         volatile unsigned long y;
  55         eax =  x;
  56         for(c = 0; c < 6; c++) {
  57                 y = * (volatile unsigned long *) eax;
  58                 eax += 0x10000000;
  59         }
  60 }
  61
  62 void dimms_write(int x)
  63 {
  64         uint8_t c;
  65         unsigned long eax = x;
  66         for(c = 0; c < 6; c++) {
  67                 *(volatile unsigned long *) eax = 0;
  68                 eax += 0x10000000;
  69         }
  70 }
  71
  72
  73
  74 #ifdef DEBUG_SETNORTHB
  75 void setnorthb(device_t north, uint8_t reg, uint8_t val)
  76 {
  77         print_debug("setnorth: reg ");
  78         print_debug_hex8(reg);
  79         print_debug(" to ");
  80         print_debug_hex8(val);
  81         print_debug("\r\n");
  82         pci_write_config8(north, reg, val);
  83 }
  84 #else
  85 #define setnorthb pci_write_config8
  86 #endif
  87
  88 void
  89 dumpnorth(device_t north)
  90 {
  91         unsigned int r, c;
  92         for(r = 0; ; r += 16) {
  93                 print_debug_hex8(r);
  94                 print_debug(":");
  95                 for(c = 0; c < 16; c++) {
  96                         print_debug_hex8(pci_read_config8(north, r+c));
  97                         print_debug(" ");
  98                 }
  99                 print_debug("\r\n");
 100                 if (r >= 240)
 101                         break;
 102   }
 103 }
 104
 105 static void sdram_set_registers(const struct mem_controller *ctrl)
 106 {
 107         device_t north = (device_t) 0;
 108         uint8_t c, r;
 109
 110         print_err("vt8601 init starting\r\n");
 111         north = pci_locate_device(PCI_ID(0x1106, 0x8601), 0);
 112         north = 0;
 113         print_debug_hex32(north);
 114         print_debug(" is the north\n");
 115         print_debug_hex16(pci_read_config16(north, 0));
 116         print_debug(" ");
 117         print_debug_hex16(pci_read_config16(north, 2));
 118         print_debug("\r\n");
 119
 120         /* All we are doing now is setting initial known-good values that will
 121          * be revised later as we read SPD
 122          */
 123         // memory clk enable. We are not using ECC
 124         pci_write_config8(north,0x78, 0x01);
 125         print_debug_hex8(pci_read_config8(north, 0x78));
 126         // dram control, see the book.
 127 #if DIMM_PC133
 128         pci_write_config8(north,0x68, 0x52);
 129 #else
 130         pci_write_config8(north,0x68, 0x42);
 131 #endif
 132         // dram control, see the book.
 133         pci_write_config8(north,0x6B, 0x0c);
 134         // Initial setting, 256MB in each bank, will be rewritten later.
 135         pci_write_config8(north,0x5A, 0x20);
 136         print_debug_hex8(pci_read_config8(north, 0x5a));
 137         pci_write_config8(north,0x5B, 0x40);
 138         pci_write_config8(north,0x5C, 0x60);
 139         pci_write_config8(north,0x5D, 0x80);
 140         pci_write_config8(north,0x5E, 0xA0);
 141         pci_write_config8(north,0x5F, 0xC0);
 142         // It seems we have to take care of these 2 registers as if
 143         // they are bank 6 and 7.
 144         pci_write_config8(north,0x56, 0xC0);
 145         pci_write_config8(north,0x57, 0xC0);
 146
 147         // SDRAM in all banks
 148         pci_write_config8(north,0x60, 0x3F);
 149         // DRAM timing. I'm suspicious of this
 150         // This is for all banks, 64 is 0,1.  65 is 2,3. 66 is 4,5.
 151         // ras precharge 4T, RAS pulse 5T
 152         // cas2 is 0xd6, cas3 is 0xe6
 153         // we're also backing off write pulse width to 2T, so result is 0xee
 154 #if DIMM_CL2
 155         pci_write_config8(north,0x64, 0xd4);
 156         pci_write_config8(north,0x65, 0xd4);
 157         pci_write_config8(north,0x66, 0xd4);
 158 #else // CL=3
 159         pci_write_config8(north,0x64, 0xe4);
 160         pci_write_config8(north,0x65, 0xe4);
 161         pci_write_config8(north,0x66, 0xe4);
 162 #endif
 163
 164         // dram frequency select.
 165         // enable 4K pages for 64M dram.
 166 #if DIMM_PC133
 167         pci_write_config8(north,0x69, 0x3c);
 168 #else
 169         pci_write_config8(north,0x69, 0xac);
 170 #endif
 171
 172         /* IMPORTANT -- disable refresh counter */
 173         // refresh counter, disabled.
 174         pci_write_config8(north,0x6A, 0x00);
 175
 176
 177         // clkenable configuration. kevinh FIXME - add precharge
 178         pci_write_config8(north,0x6C, 0x00);
 179         // dram read latch delay of 1 ns, MD drive 8 mA,
 180         // high drive strength on MA[2: 13], we#, cas#, ras#
 181         // As per Cindy Lee, set to 0x37, not 0x57
 182         pci_write_config8(north,0x6D, 0x7f);
 183 }
 184
 185 /* slot is the dram slot. Return size of side0 in lower 16-bit,
 186  * side1 in upper 16-bit, in units of 8MB */
 187 static unsigned long
 188 spd_module_size(unsigned char slot)
 189 {
 190         /* for all the DRAMS, see if they are there and get the size of each
 191          * module. This is just a very early first cut at sizing.
 192          */
 193         /* we may run out of registers ... */
 194         unsigned int banks, rows, cols, reg;
 195         unsigned int value = 0;
 196         unsigned int module = ((0x50 + slot) << 1) + 1;
 197         /* is the module there? if byte 2 is not 4, then we'll assume it
 198          * is useless.
 199          */
 200         print_info("Slot ");
 201         print_info_hex8(slot);
 202         if (smbus_read_byte(module, 2) != 4) {
 203                 print_info(" is empty\r\n");
 204                 return 0;
 205         }
 206         print_info(" is SDRAM ");
 207
 208         banks = smbus_read_byte(module, 17);
 209         /* we're going to assume symmetric banks. Sorry. */
 210         cols = smbus_read_byte(module, 4)  & 0xf;
 211         rows = smbus_read_byte(module, 3)  & 0xf;
 212         /* grand total. You have rows+cols addressing, * times of banks, times
 213          * width of data in bytes */
 214         /* Width is assumed to be 64 bits == 8 bytes */
 215         value = (1 << (cols + rows)) * banks * 8;
 216         print_info_hex32(value);
 217         print_info(" bytes ");
 218         /* Return in 8MB units */
 219         value >>= 23;
 220
 221         /* We should have single or double side */
 222         if (smbus_read_byte(module, 5) == 2) {
 223                 print_info("x2");
 224                 value = (value << 16) | value;
 225         }
 226         print_info("\r\n");
 227         return value;
 228
 229 }
 230
 231 static int
 232 spd_num_chips(unsigned char slot)
 233 {
 234         unsigned int module = ((0x50 + slot) << 1) + 1;
 235         unsigned int width;
 236
 237         width = smbus_read_byte(module, 13);
 238         if (width == 0)
 239                 width = 8;
 240         return 64 / width;
 241 }
 242
 243 static void sdram_set_spd_registers(const struct mem_controller *ctrl)
 244 {
 245 #define T133 7
 246         unsigned char Trp = 1, Tras = 1, casl = 2, val;
 247         unsigned char timing = 0xe4;
 248         /* read Trp */
 249         val = smbus_read_byte(0xa0, 27);
 250         if (val < 2*T133)
 251                 Trp = 1;
 252         val = smbus_read_byte(0xa0, 30);
 253         if (val < 5*T133)
 254                 Tras = 0;
 255         val = smbus_read_byte(0xa0, 18);
 256         if (val < 8)
 257                 casl = 1;
 258         if (val < 4)
 259                 casl = 0;
 260
 261         val = (Trp << 7) | (Tras << 6) | (casl << 4) | 4;
 262
 263         print_debug_hex8(val); print_debug(" is the computed timing\n");
 264         /* don't set it. Experience shows that this screwy chipset should just
 265          * be run with the most conservative timing.
 266          * pci_write_config8(0, 0x64, val);
 267          */
 268 }
 269
 270 static void set_ma_mapping(device_t north, int slot, int type)
 271 {
 272     unsigned char reg, val;
 273     int shift;
 274
 275     reg = 0x58 + slot/2;
 276     if (slot%2 >= 1)
 277         shift = 0;
 278     else
 279         shift = 4;
 280
 281     val = pci_read_config8(north, reg);
 282     val &= ~(0xf << shift);
 283     val |= type << shift;
 284     pci_write_config8(north, reg, val);
 285 }
 286
 287
 288 static void sdram_enable(int controllers, const struct mem_controller *ctrl)
 289 {
 290         unsigned char i;
 291         static const uint8_t ramregs[] = {
 292                 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x56, 0x57
 293         };
 294         device_t north = 0;
 295         uint32_t size, base, slot, ma;
 296         /* begin to initialize*/
 297         // I forget why we need this, but we do
 298         dimms_write(0xa55a5aa5);
 299
 300         /* set NOP*/
 301         pci_write_config8(north,0x6C, 0x01);
 302         print_debug("NOP\r\n");
 303         /* wait 200us*/
 304         // You need to do the memory reference. That causes the nop cycle.
 305         dimms_read(0);
 306         udelay(400);
 307         print_debug("PRECHARGE\r\n");
 308         /* set precharge */
 309         pci_write_config8(north,0x6C, 0x02);
 310         print_debug("DUMMY READS\r\n");
 311         /* dummy reads*/
 312         dimms_read(0);
 313         udelay(200);
 314         print_debug("CBR\r\n");
 315         /* set CBR*/
 316         pci_write_config8(north,0x6C, 0x04);
 317
 318         /* do 8 reads and wait >100us between each - from via*/
 319         dimms_read(0);
 320         udelay(200);
 321         dimms_read(0);
 322         udelay(200);
 323         dimms_read(0);
 324         udelay(200);
 325         dimms_read(0);
 326         udelay(200);
 327         dimms_read(0);
 328         udelay(200);
 329         dimms_read(0);
 330         udelay(200);
 331         dimms_read(0);
 332         udelay(200);
 333         dimms_read(0);
 334         udelay(200);
 335         print_debug("MRS\r\n");
 336         /* set MRS*/
 337         pci_write_config8(north,0x6c, 0x03);
 338 #if DIMM_CL2
 339         dimms_read(0x150);
 340 #else // CL=3
 341         dimms_read(0x1d0);
 342 #endif
 343         udelay(200);
 344         print_debug("NORMAL\r\n");
 345         /* set to normal mode */
 346         pci_write_config8(north,0x6C, 0x08);
 347
 348         dimms_write(0x55aa55aa);
 349         dimms_read(0);
 350         udelay(200);
 351         print_debug("set ref. rate\r\n");
 352         // Set the refresh rate.
 353 #if DIMM_PC133
 354         pci_write_config8(north,0x6A, 0x86);
 355 #else
 356         pci_write_config8(north,0x6A, 0x65);
 357 #endif
 358         print_debug("enable multi-page open\r\n");
 359         // enable multi-page open
 360         pci_write_config8(north,0x6B, 0x0d);
 361
 362         base = 0;
 363         for(slot = 0; slot < 4; slot++) {
 364                 size = spd_module_size(slot);
 365                 /* side 0 */
 366                 base += size & 0xffff;
 367                 pci_write_config8(north, ramregs[2*slot], base);
 368                 /* side 1 */
 369                 base += size >> 16;
 370                 if (base > 0xff)
 371                         base = 0xff;
 372                 pci_write_config8(north, ramregs[2*slot + 1], base);
 373
 374                 if (!size)
 375                         continue;
 376
 377                 /* Calculate the value of MA mapping type register,
 378                  * based on size of SDRAM chips. */
 379                 size = (size & 0xffff) << (3 + 3);
 380                         /* convert module size to be in Mbits */
 381                 size /= spd_num_chips(slot);
 382                 print_debug_hex16(size);
 383                 print_debug(" is the chip size\r\n");
 384                 if (size < 64)
 385                         ma = 0;
 386                 if (size < 256)
 387                         ma = 8;
 388                 else
 389                         ma = 0xe;
 390                 print_debug_hex16(ma);
 391                 print_debug(" is the MA type\r\n");
 392                 set_ma_mapping(north, slot, ma);
 393         }
 394         print_err("vt8601 done\r\n");
 395         dumpnorth(north);
 396 }