src/northbridge/amd/gx2/northbridgeinit.c

   1 #include <console/console.h>
   2 #include <arch/io.h>
   3 #include <stdint.h>
   4 #include <device/device.h>
   5 #include <device/pci.h>
   6 #include <device/pci_ids.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <bitops.h>
  10 #include "chip.h"
  11 #include "northbridge.h"
  12 #include <cpu/amd/gx2def.h>
  13 #include <cpu/x86/msr.h>
  14 #include <cpu/x86/cache.h>
  15
  16 /* put this here for now, we are not sure where it belongs */
  17
  18 struct gliutable {
  19         unsigned long desc_name;
  20         unsigned short desc_type;
  21         unsigned long hi, lo;
  22 };
  23
  24 struct gliutable gliu0table[] = {
  25         {.desc_name=MSR_GLIU0_BASE1, .desc_type= BM,.hi= MSR_MC + 0x0,.lo=  0x0FFF80},          /*  0-7FFFF to MC*/
  26         {.desc_name=MSR_GLIU0_BASE2, .desc_type= BM,.hi= MSR_MC + 0x0,.lo=(0x80 << 20) + 0x0FFFE0},             /*  80000-9ffff to Mc*/
  27         {.desc_name=MSR_GLIU0_SHADOW,.desc_type= SC_SHADOW,.hi=  MSR_MC + 0x0,.lo=  0x03},      /*  C0000-Fffff split to MC and PCI (sub decode) A0000-Bffff handled by SoftVideo*/
  28         {.desc_name=MSR_GLIU0_SYSMEM,.desc_type= R_SYSMEM,.hi=  MSR_MC,.lo=  0x0},              /*  Catch and fix dynamicly.*/
  29         {.desc_name=MSR_GLIU0_DMM,   .desc_type= BMO_DMM,.hi=  MSR_MC,.lo=  0x0},               /*  Catch and fix dynamicly.*/
  30         {.desc_name=MSR_GLIU0_SMM,   .desc_type= BMO_SMM,.hi=  MSR_MC,.lo=  0x0},               /*  Catch and fix dynamicly.*/
  31         {.desc_name=GLIU0_GLD_MSR_COH,.desc_type= OTHER,.hi= 0x0,.lo= GL0_CPU},
  32         {.desc_name=GL_END,          .desc_type= GL_END,.hi= 0x0,.lo= 0x0},
  33 };
  34
  35
  36 struct gliutable gliu1table[] = {
  37         {.desc_name=MSR_GLIU1_BASE1,.desc_type=  BM,.hi=  MSR_GL0 + 0x0,.lo=  0x0FFF80},        /*  0-7FFFF to MC*/
  38         {.desc_name=MSR_GLIU1_BASE2,.desc_type=  BM,.hi=  MSR_GL0 + 0x0,.lo= (0x80 << 20) +0x0FFFE0},   /*  80000-9ffff to Mc*/
  39         {.desc_name=MSR_GLIU1_SHADOW,.desc_type=  SC_SHADOW,.hi=  MSR_GL0 + 0x0,.lo=  0x03},/*  C0000-Fffff split to MC and PCI (sub decode)*/
  40         {.desc_name=MSR_GLIU1_SYSMEM,.desc_type=  R_SYSMEM,.hi=  MSR_GL0,.lo=  0x0},            /*  Cat0xc and fix dynamicly.*/
  41         {.desc_name=MSR_GLIU1_DMM,.desc_type=  BM_DMM,.hi=  MSR_GL0,.lo=  0x0},                 /*  Cat0xc and fix dynamicly.*/
  42         {.desc_name=MSR_GLIU1_SMM,.desc_type=  BM_SMM,.hi=  MSR_GL0,.lo=  0x0},                 /*  Cat0xc and fix dynamicly.*/
  43         {.desc_name=GLIU1_GLD_MSR_COH,.desc_type= OTHER,.hi= 0x0,.lo= GL1_GLIU0},
  44         {.desc_name=MSR_GLIU1_FPU_TRAP,.desc_type=  SCIO,.hi=  (GL1_GLCP << 29) + 0x0,.lo=  0x033000F0},        /*  FooGlue FPU 0xF0*/
  45         {.desc_name=GL_END,.desc_type= GL_END,.hi= 0x0,.lo= 0x0},
  46 };
  47
  48 struct gliutable *gliutables[]  = {gliu0table, gliu1table, 0};
  49
  50 struct msrinit {
  51         unsigned long msrnum;
  52         msr_t msr;
  53 };
  54
  55 struct msrinit ClockGatingDefault [] = {
  56         {GLIU0_GLD_MSR_PM,      {.hi=0x00,.lo=0x0005}},
  57                         /*  MC must stay off in SDR mode. It is turned on in CPUBug??? lotus #77.142*/
  58         {MC_GLD_MSR_PM,         {.hi=0x00,.lo=0x0000}},
  59         {GLIU1_GLD_MSR_PM,      {.hi=0x00,.lo=0x0005}},
  60         {VG_GLD_MSR_PM,         {.hi=0x00,.lo=0x0000}},                 /*  lotus #77.163*/
  61         {GP_GLD_MSR_PM,         {.hi=0x00,.lo=0x0001}},
  62         {DF_GLD_MSR_PM,         {.hi=0x00,.lo=0x0155}},
  63         {GLCP_GLD_MSR_PM,       {.hi=0x00,.lo=0x0015}},
  64         {GLPCI_GLD_MSR_PM,      {.hi=0x00,.lo=0x0015}},
  65         {FG_GLD_MSR_PM,         {.hi=0x00,.lo=0x0000}},                 /* Always on*/
  66         {0xffffffff,                            {0xffffffff, 0xffffffff}},
  67 };
  68         /*  All On*/
  69 struct msrinit ClockGatingAllOn[] = {
  70         {GLIU0_GLD_MSR_PM,      {.hi=0x00,.lo=0x0FFFFFFFF}},
  71         {MC_GLD_MSR_PM,         {.hi=0x00,.lo=0x0FFFFFFFF}},
  72         {GLIU1_GLD_MSR_PM,      {.hi=0x00,.lo=0x0FFFFFFFF}},
  73         {VG_GLD_MSR_PM,         {.hi=0x00, .lo=0x00}},
  74         {GP_GLD_MSR_PM,         {.hi=0x00,.lo=0x000000001}},
  75         {DF_GLD_MSR_PM,         {.hi=0x00,.lo=0x0FFFFFFFF}},
  76         {GLCP_GLD_MSR_PM,       {.hi=0x00,.lo=0x0FFFFFFFF}},
  77         {GLPCI_GLD_MSR_PM,      {.hi=0x00,.lo=0x0FFFFFFFF}},
  78         {FG_GLD_MSR_PM,         {.hi=0x00,.lo=0x0000}},
  79         {0xffffffff,                            {0xffffffff, 0xffffffff}},
  80 };
  81
  82         /*  Performance*/
  83 struct msrinit ClockGatingPerformance[] = {
  84         {VG_GLD_MSR_PM,         {.hi=0x00,.lo=0x0000}},                         /*  lotus #77.163*/
  85         {GP_GLD_MSR_PM,         {.hi=0x00,.lo=0x0001}},
  86         {DF_GLD_MSR_PM,         {.hi=0x00,.lo=0x0155}},
  87         {GLCP_GLD_MSR_PM,       {.hi=0x00,.lo=0x0015}},
  88         {0xffffffff,                            {0xffffffff, 0xffffffff}},
  89 };
  90 /* */
  91 /*  SET GeodeLink PRIORITY*/
  92 /* */
  93 struct msrinit GeodeLinkPriorityTable [] = {
  94         {CPU_GLD_MSR_CONFIG,            {.hi=0x00,.lo=0x0220}},         /*  CPU Priority.*/
  95         {DF_GLD_MSR_MASTER_CONF,        {.hi=0x00,.lo=0x0000}},         /*  DF Priority.*/
  96         {VG_GLD_MSR_CONFIG,             {.hi=0x00,.lo=0x0720}},         /*  VG Primary and Secondary Priority.*/
  97         {GP_GLD_MSR_CONFIG,             {.hi=0x00,.lo=0x0010}},         /*  Graphics Priority.*/
  98         {GLPCI_GLD_MSR_CONFIG,          {.hi=0x00,.lo=0x0017}},         /*  GLPCI Priority + PID*/
  99         {GLCP_GLD_MSR_CONF,             {.hi=0x00,.lo=0x0001}},         /*  GLCP Priority + PID*/
 100         {VIP_GLD_MSR_CONFIG,            {.hi=0x00,.lo=0x0622}},         /*  VIP PID*/
 101         {AES_GLD_MSR_CONFIG,            {.hi=0x00,.lo=0x0013}},         /*  AES PID*/
 102         {0x0FFFFFFFF,                   {0x0FFFFFFFF, 0x0FFFFFFFF}},    /*  END*/
 103 };
 104
 105 /* do we have dmi or not? assume yes */
 106 int havedmi = 1;
 107
 108 static void
 109 writeglmsr(struct gliutable *gl){
 110         msr_t msr;
 111
 112         msr.lo = gl->lo;
 113         msr.hi = gl->hi;
 114         wrmsr(gl->desc_name, msr);
 115         printk_debug("%s: write msr 0x%x, val 0x%x:0x%x\n", __FUNCTION__, gl->desc_name, msr.hi, msr.lo);
 116         /* they do this, so we do this */
 117         msr = rdmsr(gl->desc_name);
 118         printk_debug("%s: AFTER write msr 0x%x, val 0x%x:0x%x\n", __FUNCTION__, gl->desc_name, msr.hi, msr.lo);
 119 }
 120
 121 static void
 122 ShadowInit(struct gliutable *gl)
 123 {
 124         msr_t msr;
 125
 126         msr = rdmsr(gl->desc_name);
 127
 128         if (msr.lo == 0) {
 129                 writeglmsr(gl);
 130         }
 131 }
 132
 133 /* NOTE: transcribed from assembly code. There is the usual redundant assembly nonsense in here.
 134   * CLEAN ME UP
 135    */
 136 /* yes, this duplicates later code, but it seems that is how they want it done.
 137   */
 138 extern int sizeram(void);
 139 static void
 140 SysmemInit(struct gliutable *gl)
 141 {
 142         msr_t msr;
 143         int sizembytes, sizebytes;
 144
 145         sizembytes = sizeram();
 146         printk_debug("%s: enable for %dm bytes\n", __FUNCTION__, sizembytes);
 147         sizebytes = sizembytes << 20;
 148
 149         sizebytes -= SMM_SIZE*1024 +1;
 150
 151         if (havedmi)
 152                 sizebytes -= DMM_SIZE * 1024 + 1;
 153
 154         sizebytes -= 1;
 155         msr.hi = gl->hi | (sizebytes >> 24);
 156         /* set up sizebytes to fit into msr.lo */
 157         sizebytes <<= 8; /* what? well, we want bits 23:12 in bytes 31:20. */
 158         sizebytes &= 0xfff00000;
 159         sizebytes |= 0x100;
 160         msr.lo = sizebytes;
 161         wrmsr(gl->desc_name, msr);
 162         msr = rdmsr(gl->desc_name);
 163         printk_debug("%s: AFTER write msr 0x%x, val 0x%x:0x%x\n", __FUNCTION__,
 164                                 gl->desc_name, msr.hi, msr.lo);
 165
 166 }
 167 static void
 168 DMMGL0Init(struct gliutable *gl) {
 169         msr_t msr;
 170         int sizebytes = sizeram()<<20;
 171         long offset;
 172
 173         if (! havedmi)
 174                 return;
 175
 176         printk_debug("%s: %d bytes\n", __FUNCTION__, sizebytes);
 177
 178         sizebytes -= DMM_SIZE*1024;
 179         offset = sizebytes - DMM_OFFSET;
 180         printk_debug("%s: offset is 0x%x\n", __FUNCTION__, offset);
 181         offset >>= 12;
 182         msr.hi = (gl->hi) | (offset << 8);
 183         /* I don't think this is needed */
 184         msr.hi &= 0xffffff00;
 185         msr.hi |= (DMM_OFFSET >> 24);
 186         msr.lo = DMM_OFFSET << 8;
 187         msr.lo |= ((~(DMM_SIZE*1024)+1)>>12)&0xfffff;
 188
 189         wrmsr(gl->desc_name, msr);
 190         msr = rdmsr(gl->desc_name);
 191         printk_debug("%s: AFTER write msr 0x%x, val 0x%x:0x%x\n", __FUNCTION__, gl->desc_name, msr.hi, msr.lo);
 192
 193 }
 194 static void
 195 DMMGL1Init(struct gliutable *gl) {
 196         msr_t msr;
 197
 198         if (! havedmi)
 199                 return;
 200
 201         printk_debug("%s:\n", __FUNCTION__ );
 202
 203         msr.hi = gl->hi;
 204         /* I don't think this is needed */
 205         msr.hi &= 0xffffff00;
 206         msr.hi |= (DMM_OFFSET >> 24);
 207         msr.lo = DMM_OFFSET << 8;
 208         /* hmm. AMD source has SMM here ... SMM, not DMM? We think DMM */
 209         printk_err("%s: warning, using DMM_SIZE even though AMD used SMM_SIZE\n", __FUNCTION__);
 210         msr.lo |= ((~(DMM_SIZE*1024)+1)>>12)&0xfffff;
 211
 212         wrmsr(gl->desc_name, msr);
 213         msr = rdmsr(gl->desc_name);
 214         printk_debug("%s: AFTER write msr 0x%x, val 0x%x:0x%x\n", __FUNCTION__, gl->desc_name, msr.hi, msr.lo);
 215 }
 216 static void
 217 SMMGL0Init(struct gliutable *gl) {
 218         msr_t msr;
 219         int sizebytes = sizeram()<<20;
 220         long offset;
 221
 222         sizebytes -= SMM_SIZE*1024;
 223
 224         if (havedmi)
 225                 sizebytes -= DMM_SIZE * 1024;
 226
 227         printk_debug("%s: %d bytes\n", __FUNCTION__, sizebytes);
 228
 229         offset = sizebytes - SMM_OFFSET;
 230         printk_debug("%s: offset is 0x%x\n", __FUNCTION__, offset);
 231         offset >>= 12;
 232
 233         msr.hi = offset << 8;
 234         msr.hi |= SMM_OFFSET>>24;
 235
 236         msr.lo = SMM_OFFSET << 8;
 237         msr.lo |= ((~(SMM_SIZE*1024)+1)>>12)&0xfffff;
 238
 239         wrmsr(gl->desc_name, msr);
 240         msr = rdmsr(gl->desc_name);
 241         printk_debug("%s: AFTER write msr 0x%x, val 0x%x:0x%x\n", __FUNCTION__, gl->desc_name, msr.hi, msr.lo);
 242 }
 243 static void
 244 SMMGL1Init(struct gliutable *gl) {
 245         msr_t msr;
 246         printk_debug("%s:\n", __FUNCTION__ );
 247
 248         msr.hi = gl->hi;
 249         /* I don't think this is needed */
 250         msr.hi &= 0xffffff00;
 251         msr.hi |= (SMM_OFFSET >> 24);
 252         msr.lo = SMM_OFFSET << 8;
 253         msr.lo |= ((~(SMM_SIZE*1024)+1)>>12)&0xfffff;
 254
 255         wrmsr(gl->desc_name, msr);
 256         msr = rdmsr(gl->desc_name);
 257         printk_debug("%s: AFTER write msr 0x%x, val 0x%x:0x%x\n", __FUNCTION__, gl->desc_name, msr.hi, msr.lo);
 258 }
 259
 260 static void
 261 GLIUInit(struct gliutable *gl){
 262
 263         while (gl->desc_type != GL_END){
 264                 switch(gl->desc_type){
 265                 default:
 266                                 printk_err("%s: name %x, type %x, hi %x, lo %x: unsupported  type: ", __FUNCTION__,
 267                                                         gl->desc_name, gl->desc_type, gl->hi, gl->hi);
 268                                 printk_err("Must be %x, %x, %x, %x, %x, or %x\n", SC_SHADOW,R_SYSMEM,BMO_DMM,
 269                                                                                         BM_DMM, BMO_SMM,BM_SMM);
 270
 271                 case SC_SHADOW: /*  Check for a Shadow entry*/
 272                         ShadowInit(gl);
 273                         break;
 274
 275                 case R_SYSMEM: /*  check for a SYSMEM entry*/
 276                         SysmemInit(gl);
 277                         break;
 278
 279                 case    BMO_DMM: /*  check for a DMM entry*/
 280                         DMMGL0Init(gl);
 281                         break;
 282
 283                 case BM_DMM     : /*  check for a DMM entry*/
 284                         DMMGL1Init(gl);
 285                         break;
 286
 287                 case BMO_SMM    : /*  check for a SMM entry*/
 288                         SMMGL0Init(gl);
 289                         break;
 290
 291                 case BM_SMM     : /*  check for a SMM entry*/
 292                         SMMGL1Init(gl);
 293                         break;
 294                 }
 295                 gl++;
 296         }
 297
 298 }
 299         /* ***************************************************************************/
 300         /* **/
 301         /* *    GLPCIInit*/
 302         /* **/
 303         /* *    Set up GLPCI settings for reads/write into memory*/
 304         /* *    R0:  0-640KB,*/
 305         /* *    R1:  1MB - Top of System Memory*/
 306         /* *    R2: SMM Memory*/
 307         /* *    R3: Framebuffer? - not set up yet*/
 308         /* *    R4: ??*/
 309         /* **/
 310         /* *    Entry:*/
 311         /* *    Exit:*/
 312         /* *    Modified:*/
 313         /* **/
 314         /* ***************************************************************************/
 315 static void GLPCIInit(void){
 316         struct gliutable *gl = 0;
 317         int i;
 318         msr_t msr;
 319         int msrnum;
 320         unsigned long  val;
 321         /* */
 322         /*  R0 - GLPCI settings for Conventional Memory space.*/
 323         /* */
 324         msr.hi =  (0x09F000 >> 12) << GLPCI_RC_UPPER_TOP_SHIFT          /*  640*/;
 325         msr.lo =  0                                                                                                     /*  0*/;
 326         msr.lo |= GLPCI_RC_LOWER_EN_SET+ GLPCI_RC_LOWER_PF_SET + GLPCI_RC_LOWER_WC_SET;
 327         msrnum = GLPCI_RC0;
 328         wrmsr(msrnum, msr);
 329
 330         /* */
 331         /*  R1 - GLPCI settings for SysMem space.*/
 332         /* */
 333         /*  Get systop from GLIU0 SYSTOP Descriptor*/
 334         for(i = 0; gliu0table[i].desc_name != GL_END; i++) {
 335                 if (gliu0table[i].desc_type == R_SYSMEM) {
 336                         gl = &gliu0table[i];
 337                         break;
 338                 }
 339         }
 340         if (gl) {
 341                 unsigned long pah, pal;
 342                 msrnum = gl->desc_name;
 343                 msr = rdmsr(msrnum);
 344                 /* example R_SYSMEM value: 20:00:00:0f:fb:f0:01:00
 345                  * translates to a base of 0x00100000 and top of 0xffbf0000
 346                  * base of 1M and top of around 256M
 347                  */
 348                 /* we have to create a page-aligned (4KB page) address for base and top */
 349                 /* So we need a high page aligned addresss (pah) and low page aligned address (pal)
 350                  * pah is from msr.hi << 12 | msr.low >> 20. pal is msr.lo << 12
 351                  */
 352                 printk_debug("GLPCI r1: system msr.lo 0x%x msr.hi 0x%x\n", msr.lo, msr.hi);
 353                 pah = ((msr.hi &0xff) << 12) | ((msr.lo >> 20) & 0xfff);
 354                 /* we have the page address. Now make it a page-aligned address */
 355                 pah <<= 12;
 356
 357                 pal = msr.lo << 12;
 358                 msr.hi =  pah;
 359                 msr.lo =  pal;
 360                 msr.lo |= GLPCI_RC_LOWER_EN_SET | GLPCI_RC_LOWER_PF_SET | GLPCI_RC_LOWER_WC_SET;
 361                 printk_debug("GLPCI r1: system msr.lo 0x%x msr.hi 0x%x\n", msr.lo, msr.hi);
 362                 msrnum = GLPCI_RC1;
 363                 wrmsr(msrnum, msr);
 364         }
 365
 366         /* */
 367         /*  R2 - GLPCI settings for SMM space.*/
 368         /* */
 369         msr.hi =  ((SMM_OFFSET+(SMM_SIZE*1024-1)) >> 12) << GLPCI_RC_UPPER_TOP_SHIFT;
 370         msr.lo =  (SMM_OFFSET >> 12) << GLPCI_RC_LOWER_BASE_SHIFT;
 371         msr.lo |= GLPCI_RC_LOWER_EN_SET | GLPCI_RC_LOWER_PF_SET;
 372         msrnum = GLPCI_RC2;
 373         wrmsr(msrnum, msr);
 374
 375         /* this is done elsewhere already, but it does no harm to do it more than once */
 376         /*  write serialize memory hole to PCI. Need to to unWS when something is shadowed regardless of cachablility.*/
 377         msr.lo =  0x021212121                                                           /*  cache disabled and write serialized*/;
 378         msr.hi =  0x021212121                                                           /*  cache disabled and write serialized*/;
 379
 380         msrnum = CPU_RCONF_A0_BF;
 381         wrmsr(msrnum, msr);
 382
 383         msrnum = CPU_RCONF_C0_DF;
 384         wrmsr(msrnum, msr);
 385
 386         msrnum = CPU_RCONF_E0_FF;
 387         wrmsr(msrnum, msr);
 388
 389         /*  Set Non-Cacheable Read Only for NorthBound Transactions to Memory. The Enable bit is handled in the Shadow setup.*/
 390         msrnum = GLPCI_A0_BF;
 391         msr.hi =  0x35353535;
 392         msr.lo =  0x35353535;
 393         wrmsr(msrnum, msr);
 394
 395         msrnum = GLPCI_C0_DF;
 396         msr.hi =  0x35353535;
 397         msr.lo =  0x35353535;
 398         wrmsr(msrnum, msr);
 399
 400         msrnum = GLPCI_E0_FF;
 401         msr.hi =  0x35353535;
 402         msr.lo =  0x35353535;
 403         wrmsr(msrnum, msr);
 404
 405         /*  Set WSREQ*/
 406         msrnum = CPU_DM_CONFIG0;
 407         msr = rdmsr(msrnum);
 408         msr.hi &= ~ (7 << DM_CONFIG0_UPPER_WSREQ_SHIFT);
 409         msr.hi |= 2 << DM_CONFIG0_UPPER_WSREQ_SHIFT     ;       /*  reduce to 1 for safe mode.*/
 410         wrmsr(msrnum, msr);
 411
 412         /* we are ignoring the 5530 case for now, and perhaps forever. */
 413
 414         /* */
 415         /* 5535 NB Init*/
 416         /* */
 417         msrnum = GLPCI_ARB;
 418         msr = rdmsr(msrnum);
 419         msr.hi |=  GLPCI_ARB_UPPER_PRE0_SET | GLPCI_ARB_UPPER_PRE1_SET;
 420         msr.lo |=  GLPCI_ARB_LOWER_IIE_SET;
 421         wrmsr(msrnum, msr);
 422
 423
 424         msrnum = GLPCI_CTRL;
 425         msr = rdmsr(msrnum);
 426
 427         msr.lo |=  GLPCI_CTRL_LOWER_ME_SET | GLPCI_CTRL_LOWER_OWC_SET | GLPCI_CTRL_LOWER_PCD_SET;       /*   (Out will be disabled in CPUBUG649 for < 2.0 parts .)*/
 428         msr.lo |=  GLPCI_CTRL_LOWER_LDE_SET;
 429
 430         msr.lo &=  ~ (0x03 << GLPCI_CTRL_LOWER_IRFC_SHIFT);
 431         msr.lo |=  0x02 << GLPCI_CTRL_LOWER_IRFC_SHIFT;
 432
 433         msr.lo &=  ~ (0x07 << GLPCI_CTRL_LOWER_IRFT_SHIFT);
 434         msr.lo |=  0x06 << GLPCI_CTRL_LOWER_IRFT_SHIFT;
 435
 436         msr.hi &=  ~ (0x0f << GLPCI_CTRL_UPPER_FTH_SHIFT);
 437         msr.hi |=  0x0F << GLPCI_CTRL_UPPER_FTH_SHIFT;
 438
 439         msr.hi &=  ~ (0x0f << GLPCI_CTRL_UPPER_RTH_SHIFT);
 440         msr.hi |=  0x0F << GLPCI_CTRL_UPPER_RTH_SHIFT;
 441
 442         msr.hi &=  ~ (0x0f << GLPCI_CTRL_UPPER_SBRTH_SHIFT);
 443         msr.hi |=  0x0F << GLPCI_CTRL_UPPER_SBRTH_SHIFT;
 444
 445         msr.hi &=  ~ (0x03 << GLPCI_CTRL_UPPER_WTO_SHIFT);
 446         msr.hi |=  0x06 << GLPCI_CTRL_UPPER_WTO_SHIFT;
 447
 448         msr.hi &=  ~ (0x03 << GLPCI_CTRL_UPPER_ILTO_SHIFT);
 449         msr.hi |=  0x00 << GLPCI_CTRL_UPPER_ILTO_SHIFT;
 450         wrmsr(msrnum, msr);
 451
 452
 453         /*  Set GLPCI Latency Timer.*/
 454         msrnum = GLPCI_CTRL;
 455         msr = rdmsr(msrnum);
 456         msr.hi |=  0x1F << GLPCI_CTRL_UPPER_LAT_SHIFT;  /*  Change once 1.x is gone.*/
 457         wrmsr(msrnum, msr);
 458
 459         /*  GLPCI_SPARE*/
 460         msrnum = GLPCI_SPARE;
 461         msr = rdmsr(msrnum);
 462         msr.lo &=  ~ 0x7;
 463         msr.lo |=  GLPCI_SPARE_LOWER_AILTO_SET | GLPCI_SPARE_LOWER_PPD_SET | GLPCI_SPARE_LOWER_PPC_SET | GLPCI_SPARE_LOWER_MPC_SET | GLPCI_SPARE_LOWER_NSE_SET | GLPCI_SPARE_LOWER_SUPO_SET;
 464         wrmsr(msrnum, msr);
 465
 466 }
 467
 468
 469
 470         /* ***************************************************************************/
 471         /* **/
 472         /* *    ClockGatingInit*/
 473         /* **/
 474         /* *    Enable Clock Gating.*/
 475         /* **/
 476         /* *    Entry:*/
 477         /* *    Exit:*/
 478         /* *    Modified:*/
 479         /* **/
 480         /* ***************************************************************************/
 481 static void
 482 ClockGatingInit (void){
 483         msr_t msr;
 484         struct msrinit *gating = ClockGatingDefault;
 485         int i;
 486
 487 #if 0
 488         mov     cx, TOKEN_CLK_GATE
 489         NOSTACK bx, GetNVRAMValueBX
 490         cmp     al, TVALUE_CG_OFF
 491         je      gatingdone
 492
 493         cmp     al, TVALUE_CG_DEFAULT
 494         jb      allon
 495         ja      performance
 496         lea     si, ClockGatingDefault
 497         jmp     nextdevice
 498
 499 allon:
 500         lea     si, ClockGatingAllOn
 501         jmp     nextdevice
 502
 503 performance:
 504         lea     si, ClockGatingPerformance
 505 #endif
 506
 507         for(i = 0; gating->msrnum != 0xffffffff; i++) {
 508                 msr = rdmsr(gating->msrnum);
 509                 printk_debug("%s: MSR 0x%x is 0x%x:0x%x\n", __FUNCTION__, gating->msrnum, msr.hi, msr.lo);
 510                 msr.hi |= gating->msr.hi;
 511                 msr.lo |= gating->msr.lo;
 512                 printk_debug("%s: MSR 0x%x will be set to  0x%x:0x%x\n", __FUNCTION__,
 513                         gating->msrnum, msr.hi, msr.lo);
 514                 wrmsr(gating->msrnum, msr);
 515                 gating +=1;
 516         }
 517
 518 }
 519
 520 static void
 521 GeodeLinkPriority(void){
 522         msr_t msr;
 523         struct msrinit *prio = GeodeLinkPriorityTable;
 524         int i;
 525
 526         for(i = 0; prio->msrnum != 0xffffffff; i++) {
 527                 msr = rdmsr(prio->msrnum);
 528                 printk_debug("%s: MSR 0x%x is 0x%x:0x%x\n", __FUNCTION__, prio->msrnum, msr.hi, msr.lo);
 529                 msr.hi |= prio->msr.hi;
 530                 msr.lo &= ~0xfff;
 531                 msr.lo |= prio->msr.lo;
 532                 printk_debug("%s: MSR 0x%x will be set to  0x%x:0x%x\n", __FUNCTION__,
 533                         prio->msrnum, msr.hi, msr.lo);
 534                 wrmsr(prio->msrnum, msr);
 535                 prio +=1;
 536         }
 537 }
 538
 539         /* ***************************************************************************/
 540         /* **/
 541         /* *    northBridgeInit*/
 542         /* **/
 543         /* *    Core Logic initialization:  Host bridge*/
 544         /* **/
 545         /* *    Entry:*/
 546         /* *    Exit:*/
 547         /* *    Modified:*/
 548         /* **/
 549         /* ***************************************************************************/
 550
 551 void
 552 northbridgeinit(void)
 553 {
 554         int i;
 555         printk_debug("Enter %s\n", __FUNCTION__);
 556
 557         for(i = 0; gliutables[i]; i++)
 558                 GLIUInit(gliutables[i]);
 559
 560         GeodeLinkPriority();
 561
 562
 563         /*  Now that the descriptor to memory is set up.*/
 564         /*  The memory controller needs one read to synch it's lines before it can be used.*/
 565         i = *(int *) 0;
 566
 567         GLPCIInit();
 568         ClockGatingInit();
 569         __asm__("FINIT\n");
 570         /* CPUBugsFix -- called elsewhere */
 571         printk_debug("Exit %s\n", __FUNCTION__);
 572 }
 573