src/cpu/amd/model_10xxx/init_cpus.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * Copyright (C) 2007-2008 Advanced Micro Devices, Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; version 2 of the License.
   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 "defaults.h"
  21
  22 //it takes the ENABLE_APIC_EXT_ID and APIC_ID_OFFSET and LIFT_BSP_APIC_ID
  23 #ifndef FAM10_SET_FIDVID
  24         #define FAM10_SET_FIDVID 1
  25 #endif
  26
  27 #ifndef FAM10_SET_FIDVID_CORE0_ONLY
  28         /* MSR FIDVID_CTL and FIDVID_STATUS are shared by cores,
  29            Need to do every AP to set common FID/VID*/
  30         #define FAM10_SET_FIDVID_CORE0_ONLY 0
  31 #endif
  32
  33 static inline void print_initcpu8 (const char *strval, u8 val)
  34 {
  35         printk_debug("%s%02x\n", strval, val);
  36 }
  37
  38 static inline void print_initcpu8_nocr (const char *strval, u8 val)
  39 {
  40         printk_debug("%s%02x", strval, val);
  41 }
  42
  43
  44 static inline void print_initcpu16 (const char *strval, u16 val)
  45 {
  46         printk_debug("%s%04x\n", strval, val);
  47 }
  48
  49
  50 static inline void print_initcpu(const char *strval, u32 val)
  51 {
  52         printk_debug("%s%08x\n", strval, val);
  53 }
  54
  55
  56 void update_microcode(u32 cpu_deviceid);
  57 static void prep_fid_change(void);
  58 static void init_fidvid_stage2(u32 apicid, u32 nodeid);
  59 void cpuSetAMDMSR(void);
  60
  61 #if PCI_IO_CFG_EXT == 1
  62 static inline void set_EnableCf8ExtCfg(void)
  63 {
  64         // set the NB_CFG[46]=1;
  65         msr_t msr;
  66         msr = rdmsr(NB_CFG_MSR);
  67         // EnableCf8ExtCfg: We need that to access PCI_IO_CFG_EXT 4K range
  68         msr.hi |= (1<<(46-32));
  69         wrmsr(NB_CFG_MSR, msr);
  70 }
  71 #else
  72 static inline void set_EnableCf8ExtCfg(void) { }
  73 #endif
  74
  75
  76 /*[39:8] */
  77 #define PCI_MMIO_BASE 0xfe000000
  78 /* because we will use gs to store hi, so need to make sure lo can start
  79    from 0, So PCI_MMIO_BASE & 0x00ffffff should be equal to 0*/
  80
  81 static inline void set_pci_mmio_conf_reg(void)
  82 {
  83 #if MMCONF_SUPPORT
  84         msr_t msr;
  85         msr = rdmsr(0xc0010058);
  86         msr.lo &= ~(0xfff00000 | (0xf << 2));
  87         // 256 bus per segment, MMIO reg will be 4G , enable MMIO Config space
  88         msr.lo |= ((8+PCI_BUS_SEGN_BITS) << 2) | (1 << 0);
  89         msr.hi &= ~(0x0000ffff);
  90         msr.hi |= (PCI_MMIO_BASE >> (32-8));
  91         wrmsr(0xc0010058, msr); // MMIO Config Base Address Reg
  92
  93         //mtrr for that range?
  94 //      set_var_mtrr_x(7, PCI_MMIO_BASE<<8, PCI_MMIO_BASE>>(32-8), 0x00000000, 0x01, MTRR_TYPE_UNCACHEABLE);
  95
  96         set_wrap32dis();
  97
  98         msr.hi = (PCI_MMIO_BASE >> (32-8));
  99         msr.lo = 0;
 100         wrmsr(0xc0000101, msr); //GS_Base Reg
 101
 102
 103
 104 #endif
 105 }
 106
 107
 108 typedef void (*process_ap_t)(u32 apicid, void *gp);
 109
 110 //core_range = 0 : all cores
 111 //core range = 1 : core 0 only
 112 //core range = 2 : cores other than core0
 113
 114 static void for_each_ap(u32 bsp_apicid, u32 core_range,
 115                                 process_ap_t process_ap, void *gp)
 116 {
 117         // here assume the OS don't change our apicid
 118         u32 ap_apicid;
 119
 120         u32 nodes;
 121         u32 siblings;
 122         u32 disable_siblings;
 123         u32 cores_found;
 124         u32 nb_cfg_54;
 125         int i,j;
 126         u32 ApicIdCoreIdSize;
 127
 128         /* get_nodes define in ht_wrapper.c */
 129         nodes = get_nodes();
 130
 131         disable_siblings = !CONFIG_LOGICAL_CPUS;
 132
 133 #if CONFIG_LOGICAL_CPUS == 1
 134         if(read_option(CMOS_VSTART_quad_core, CMOS_VLEN_quad_core, 0) != 0) { // 0 mean quad core
 135                 disable_siblings = 1;
 136         }
 137 #endif
 138
 139         /* Assume that all node are same stepping, otherwise we can use use
 140            nb_cfg_54 from bsp for all nodes */
 141         nb_cfg_54 = read_nb_cfg_54();
 142
 143         ApicIdCoreIdSize = (cpuid_ecx(0x80000008) >> 12 & 0xf);
 144         if(ApicIdCoreIdSize) {
 145                 siblings = ((1 << ApicIdCoreIdSize) - 1);
 146         } else {
 147                 siblings = 3; //quad core
 148         }
 149
 150         for (i = 0; i < nodes; i++) {
 151                 cores_found = get_core_num_in_bsp(i);
 152
 153                 u32 jstart, jend;
 154
 155                 if (core_range == 2) {
 156                         jstart = 1;
 157                 } else {
 158                         jstart = 0;
 159                 }
 160
 161                 if (disable_siblings || (core_range==1)) {
 162                         jend = 0;
 163                 } else {
 164                         jend = cores_found;
 165                 }
 166
 167
 168                 for (j = jstart; j <= jend; j++) {
 169                         ap_apicid = i * (nb_cfg_54 ? (siblings + 1):1) + j * (nb_cfg_54 ? 1:64);
 170
 171                 #if (ENABLE_APIC_EXT_ID == 1) && (APIC_ID_OFFSET > 0)
 172                         #if LIFT_BSP_APIC_ID == 0
 173                         if( (i != 0) || (j != 0)) /* except bsp */
 174                         #endif
 175                                 ap_apicid += APIC_ID_OFFSET;
 176                 #endif
 177
 178                         if(ap_apicid == bsp_apicid) continue;
 179
 180                         process_ap(ap_apicid, gp);
 181
 182                 }
 183         }
 184 }
 185
 186 /* FIXME: Duplicate of what is in lapic.h? */
 187 static inline int lapic_remote_read(int apicid, int reg, u32 *pvalue)
 188 {
 189         int timeout;
 190         u32 status;
 191         int result;
 192         lapic_wait_icr_idle();
 193         lapic_write(LAPIC_ICR2, SET_LAPIC_DEST_FIELD(apicid));
 194         lapic_write(LAPIC_ICR, LAPIC_DM_REMRD | (reg >> 4));
 195         timeout = 0;
 196
 197         do {
 198                 status = lapic_read(LAPIC_ICR) & LAPIC_ICR_BUSY;
 199         } while (status == LAPIC_ICR_BUSY && timeout++ < 1000);
 200
 201         timeout = 0;
 202         do {
 203                 status = lapic_read(LAPIC_ICR) & LAPIC_ICR_RR_MASK;
 204         } while (status == LAPIC_ICR_RR_INPROG && timeout++ < 1000);
 205
 206         result = -1;
 207
 208         if (status == LAPIC_ICR_RR_VALID) {
 209                 *pvalue = lapic_read(LAPIC_RRR);
 210                 result = 0;
 211         }
 212         return result;
 213 }
 214
 215
 216 /* Use the LAPIC timer count register to hold each cores init status */
 217 #define LAPIC_MSG_REG 0x380
 218
 219
 220 #if FAM10_SET_FIDVID == 1
 221 static void init_fidvid_ap(u32 bsp_apicid, u32 apicid, u32 nodeid, u32 coreid);
 222 #endif
 223
 224 static inline __attribute__((always_inline)) void print_apicid_nodeid_coreid(u32 apicid, struct node_core_id id, const char *str)
 225 {
 226                 printk_debug("%s --- {   APICID = %02x NODEID = %02x COREID = %02x} ---\n", str, apicid, id.nodeid, id.coreid);
 227 }
 228
 229
 230 static unsigned wait_cpu_state(u32 apicid, u32 state)
 231 {
 232         u32 readback = 0;
 233         u32 timeout = 1;
 234         int loop = 4000000;
 235         while (--loop > 0) {
 236                 if (lapic_remote_read(apicid, LAPIC_MSG_REG, &readback) != 0) continue;
 237                 if ((readback & 0x3f) == state) {
 238                         timeout = 0;
 239                         break; //target cpu is in stage started
 240                 }
 241         }
 242         if (timeout) {
 243                 if (readback) {
 244                         timeout = readback;
 245                 }
 246         }
 247
 248         return timeout;
 249 }
 250
 251
 252 static void wait_ap_started(u32 ap_apicid, void *gp )
 253 {
 254         u32 timeout;
 255         timeout = wait_cpu_state(ap_apicid, 0x13); // started
 256         if(timeout) {
 257                 print_initcpu8_nocr("* AP ", ap_apicid);
 258                 print_initcpu(" didn't start timeout:", timeout);
 259         }
 260         else {
 261                 print_initcpu8_nocr("AP started: ", ap_apicid);
 262         }
 263 }
 264
 265
 266 static void wait_all_other_cores_started(u32 bsp_apicid)
 267 {
 268         // all aps other than core0
 269         print_debug("started ap apicid: ");
 270         for_each_ap(bsp_apicid, 2 , wait_ap_started, (void *)0);
 271         print_debug("\n");
 272 }
 273
 274
 275 static void allow_all_aps_stop(u32 bsp_apicid)
 276 {
 277         /* Called by the BSP to indicate AP can stop */
 278
 279         /* FIXME Do APs use this?
 280            Looks like wait_till_sysinfo_in_ram is used instead. */
 281
 282         // allow aps to stop use 6 bits for state
 283         lapic_write(LAPIC_MSG_REG, (bsp_apicid << 24) | 0x14);
 284 }
 285
 286 static void enable_apic_ext_id(u32 node)
 287 {
 288         u32 val;
 289
 290         val = pci_read_config32(NODE_HT(node), 0x68);
 291         val |= (HTTC_APIC_EXT_SPUR | HTTC_APIC_EXT_ID | HTTC_APIC_EXT_BRD_CST);
 292         pci_write_config32(NODE_HT(node), 0x68, val);
 293 }
 294
 295
 296 static void STOP_CAR_AND_CPU()
 297 {
 298         disable_cache_as_ram(); // inline
 299         stop_this_cpu();
 300 }
 301
 302
 303 #ifndef MEM_TRAIN_SEQ
 304 #define MEM_TRAIN_SEQ 0
 305 #endif
 306
 307 #if RAMINIT_SYSINFO == 1
 308 static u32 init_cpus(u32 cpu_init_detectedx ,struct sys_info *sysinfo)
 309 #else
 310 static u32 init_cpus(u32 cpu_init_detectedx)
 311 #endif
 312 {
 313         u32 bsp_apicid = 0;
 314         u32 apicid;
 315         struct node_core_id id;
 316
 317         /*
 318          * already set early mtrr in cache_as_ram.inc
 319          */
 320
 321         /* enable access pci conf via mmio*/
 322         set_pci_mmio_conf_reg();
 323
 324         /* that is from initial apicid, we need nodeid and coreid
 325            later */
 326         id = get_node_core_id_x();
 327
 328         /* NB_CFG MSR is shared between cores, so we need make sure
 329           core0 is done at first --- use wait_all_core0_started  */
 330         if(id.coreid == 0) {
 331                 set_apicid_cpuid_lo(); /* only set it on core0 */
 332                 set_EnableCf8ExtCfg(); /* only set it on core0 */
 333                 #if (ENABLE_APIC_EXT_ID == 1)
 334                 enable_apic_ext_id(id.nodeid);
 335                 #endif
 336         }
 337
 338         enable_lapic();
 339
 340
 341 #if (ENABLE_APIC_EXT_ID == 1) && (APIC_ID_OFFSET > 0)
 342         u32 initial_apicid = get_initial_apicid();
 343
 344         #if LIFT_BSP_APIC_ID == 0
 345         if( initial_apicid != 0 ) // other than bsp
 346         #endif
 347         {
 348                 /* use initial apic id to lift it */
 349                 u32 dword = lapic_read(LAPIC_ID);
 350                 dword &= ~(0xff << 24);
 351                 dword |= (((initial_apicid + APIC_ID_OFFSET) & 0xff) << 24);
 352
 353                 lapic_write(LAPIC_ID, dword);
 354         }
 355
 356         #if LIFT_BSP_APIC_ID == 1
 357         bsp_apicid += APIC_ID_OFFSET;
 358         #endif
 359
 360 #endif
 361
 362         /* get the apicid, it may be lifted already */
 363         apicid = lapicid();
 364
 365         // show our apicid, nodeid, and coreid
 366         if( id.coreid==0 ) {
 367                 if (id.nodeid!=0) //all core0 except bsp
 368                         print_apicid_nodeid_coreid(apicid, id, " core0: ");
 369         }
 370         else { //all other cores
 371                 print_apicid_nodeid_coreid(apicid, id, " corex: ");
 372         }
 373
 374
 375         if (cpu_init_detectedx) {
 376                 print_apicid_nodeid_coreid(apicid, id, "\n\n\nINIT detected from ");
 377                 print_debug("\nIssuing SOFT_RESET...\n");
 378                 soft_reset();
 379         }
 380
 381         if(id.coreid == 0) {
 382                 if(!(warm_reset_detect(id.nodeid))) //FIXME: INIT is checked above but check for more resets?
 383                         distinguish_cpu_resets(id.nodeid); // Also indicates we are started
 384         }
 385
 386         // Mark the core as started.
 387         lapic_write(LAPIC_MSG_REG, (apicid << 24) | 0x13);
 388
 389
 390         if(apicid != bsp_apicid) {
 391                 /* Setup each AP's cores MSRs.
 392                  * This happens after HTinit.
 393                  * The BSP runs this code in it's own path.
 394                  */
 395                 update_microcode(cpuid_eax(1));
 396                 cpuSetAMDMSR();
 397
 398
 399 #if FAM10_SET_FIDVID == 1
 400         #if (CONFIG_LOGICAL_CPUS == 1)  && (FAM10_SET_FIDVID_CORE0_ONLY == 1)
 401                 // Run on all AP for proper FID/VID setup.
 402                 if(id.coreid == 0 ) // only need set fid for core0
 403         #endif
 404                 {
 405                 // check warm(bios) reset to call stage2 otherwise do stage1
 406                         if (warm_reset_detect(id.nodeid)) {
 407                                 printk_debug("init_fidvid_stage2 apicid: %02x\n", apicid);
 408                                 init_fidvid_stage2(apicid, id.nodeid);
 409                         } else {
 410                                 printk_debug("init_fidvid_ap(stage1) apicid: %02x\n", apicid);
 411                                 init_fidvid_ap(bsp_apicid, apicid, id.nodeid, id.coreid);
 412                         }
 413                 }
 414 #endif
 415
 416                 /* AP is ready, Wait for the BSP to get memory configured */
 417                 /* FIXME: many cores spinning on node0 pci register seems to be bad.
 418                  * Why do we need to wait? These APs are just going to go sit in a hlt.
 419                  */
 420                 //wait_till_sysinfo_in_ram();
 421
 422                 set_init_ram_access();
 423
 424                 STOP_CAR_AND_CPU();
 425                 printk_debug("\nAP %02x should be halted but you are reading this....\n", apicid);
 426         }
 427
 428         return bsp_apicid;
 429 }
 430
 431
 432 static u32 is_core0_started(u32 nodeid)
 433 {
 434         u32 htic;
 435         device_t device;
 436         device = NODE_PCI(nodeid, 0);
 437         htic = pci_read_config32(device, HT_INIT_CONTROL);
 438         htic &= HTIC_ColdR_Detect;
 439         return htic;
 440 }
 441
 442
 443 static void wait_all_core0_started(void)
 444 {
 445         /* When core0 is started, it will distingush_cpu_resets
 446           . So wait for that to finish */
 447         u32 i;
 448         u32 nodes = get_nodes();
 449
 450         printk_debug("Wait all core0s started \n");
 451         for(i=1;i<nodes;i++) { // skip bsp, because it is running on bsp
 452                 while(!is_core0_started(i)) {}
 453                 print_initcpu8("  Core0 started on node: ", i);
 454         }
 455         printk_debug("Wait all core0s started done\n");
 456 }
 457 #if CONFIG_MAX_PHYSICAL_CPUS > 1
 458 /**
 459  * void start_node(u32 node)
 460  *
 461  *  start the core0 in node, so it can generate HT packet to feature code.
 462  *
 463  * This function starts the AP nodes core0s. wait_all_core0_started() in
 464  * cache_as_ram_auto.c waits for all the AP to be finished before continuing
 465  * system init.
 466  */
 467 static void start_node(u8 node)
 468 {
 469         u32 val;
 470
 471         /* Enable routing table */
 472         printk_debug("Start node %02x", node);
 473
 474 #if CAR_FAM10 == 1
 475         /* For CAR_FAM10 support, we need to set Dram base/limit for the new node */
 476         pci_write_config32(NODE_MP(node), 0x44, 0);
 477         pci_write_config32(NODE_MP(node), 0x40, 3);
 478 #endif
 479
 480         /* Allow APs to make requests (ROM fetch) */
 481         val=pci_read_config32(NODE_HT(node), 0x6c);
 482         val &= ~(1 << 1);
 483         pci_write_config32(NODE_HT(node), 0x6c, val);
 484
 485         printk_debug(" done.\n");
 486 }
 487
 488
 489 /**
 490  * static void setup_remote_node(u32 node)
 491  *
 492  * Copy the BSP Adress Map to each AP.
 493  */
 494 static void setup_remote_node(u8 node)
 495 {
 496         /* There registers can be used with F1x114_x Address Map at the
 497            same time, So must set them even 32 node */
 498         static const u16 pci_reg[] = {
 499                 /* DRAM Base/Limits Registers */
 500                 0x44, 0x4c, 0x54, 0x5c, 0x64, 0x6c, 0x74, 0x7c,
 501                 0x40, 0x48, 0x50, 0x58, 0x60, 0x68, 0x70, 0x78,
 502                 0x144, 0x14c, 0x154, 0x15c, 0x164, 0x16c, 0x174, 0x17c,
 503                 0x140, 0x148, 0x150, 0x158, 0x160, 0x168, 0x170, 0x178,
 504                 /* MMIO Base/Limits Registers */
 505                 0x84, 0x8c, 0x94, 0x9c, 0xa4, 0xac, 0xb4, 0xbc,
 506                 0x80, 0x88, 0x90, 0x98, 0xa0, 0xa8, 0xb0, 0xb8,
 507                 /* IO Base/Limits Registers */
 508                 0xc4, 0xcc, 0xd4, 0xdc,
 509                 0xc0, 0xc8, 0xd0, 0xd8,
 510                 /* Configuration Map Registers */
 511                 0xe0, 0xe4, 0xe8, 0xec,
 512         };
 513         u16 i;
 514
 515         printk_debug("setup_remote_node: %02x", node);
 516
 517         /* copy the default resource map from node 0 */
 518         for(i = 0; i < sizeof(pci_reg)/sizeof(pci_reg[0]); i++) {
 519                 u32 value;
 520                 u16 reg;
 521                 reg = pci_reg[i];
 522                 value = pci_read_config32(NODE_MP(0), reg);
 523                 pci_write_config32(NODE_MP(node), reg, value);
 524
 525         }
 526         printk_debug(" done\n");
 527 }
 528 #endif  /* CONFIG_MAX_PHYSICAL_CPUS > 1 */
 529
 530 void AMD_Errata281(u8 node, u32 revision, u32 platform)
 531 {
 532         /* Workaround for Transaction Scheduling Conflict in
 533          * Northbridge Cross Bar.  Implement XCS Token adjustment
 534          * for ganged links.  Also, perform fix up for the mixed
 535          * revision case.
 536          */
 537
 538         u32 reg, val;
 539         u8 i;
 540         u8 mixed = 0;
 541         u8 nodes = get_nodes();
 542
 543         if (platform & AMD_PTYPE_SVR) {
 544                 /* For each node we need to check for a "broken" node */
 545                 if (!(revision & (AMD_DR_B0 | AMD_DR_B1))) {
 546                         for (i = 0; i < nodes; i++) {
 547                                 if (mctGetLogicalCPUID(i) & (AMD_DR_B0 | AMD_DR_B1)) {
 548                                         mixed = 1;
 549                                         break;
 550                                 }
 551                         }
 552                 }
 553
 554                 if ((revision & (AMD_DR_B0 | AMD_DR_B1)) || mixed) {
 555
 556                         /* F0X68[22:21] DsNpReqLmt0 = 01b */
 557                         val = pci_read_config32(NODE_PCI(node, 0), 0x68);
 558                         val &= ~0x00600000;
 559                         val |= 0x00200000;
 560                         pci_write_config32(NODE_PCI(node, 0), 0x68, val);
 561
 562                         /* F3X6C */
 563                         val = pci_read_config32(NODE_PCI(node, 3), 0x6C);
 564                         val &= ~0x700780F7;
 565                         val |= 0x00010094;
 566                         pci_write_config32(NODE_PCI(node, 3), 0x6C, val);
 567
 568                         /* F3X7C */
 569                         val = pci_read_config32(NODE_PCI(node, 3), 0x7C);
 570                         val &= ~0x707FFF1F;
 571                         val |= 0x00144514;
 572                         pci_write_config32(NODE_PCI(node, 3), 0x7C, val);
 573
 574                         /* F3X144[3:0] RspTok = 0001b */
 575                         val = pci_read_config32(NODE_PCI(node, 3), 0x144);
 576                         val &= ~0x0000000F;
 577                         val |= 0x00000001;
 578                         pci_write_config32(NODE_PCI(node, 3), 0x144, val);
 579
 580                         for (i = 0; i < 3; i++) {
 581                                 reg = 0x148 + (i * 4);
 582                                 val = pci_read_config32(NODE_PCI(node, 3), reg);
 583                                 val &= ~0x000000FF;
 584                                 val |= 0x000000DB;
 585                                 pci_write_config32(NODE_PCI(node, 3), reg, val);
 586                         }
 587                 }
 588         }
 589 }
 590
 591
 592 void AMD_Errata298(void)
 593 {
 594         /* Workaround for L2 Eviction May Occur during operation to
 595          * set Accessed or dirty bit.
 596          */
 597
 598         msr_t msr;
 599         u8 i;
 600         u8 affectedRev = 0;
 601         u8 nodes = get_nodes();
 602
 603         /* For each core we need to check for a "broken" node */
 604         for (i = 0; i < nodes; i++) {
 605                 if (mctGetLogicalCPUID(i) & (AMD_DR_B0 | AMD_DR_B1 | AMD_DR_B2)) {
 606                         affectedRev = 1;
 607                         break;
 608                 }
 609         }
 610
 611         if (affectedRev) {
 612                 msr = rdmsr(HWCR);
 613                 msr.lo |= 0x08;         /* Set TlbCacheDis bit[3] */
 614                 wrmsr(HWCR, msr);
 615
 616                 msr = rdmsr(BU_CFG);
 617                 msr.lo |= 0x02;         /* Set TlbForceMemTypeUc bit[1] */
 618                 wrmsr(BU_CFG, msr);
 619
 620                 msr = rdmsr(OSVW_ID_Length);
 621                 msr.lo |= 0x01;         /* OS Visible Workaround - MSR */
 622                 wrmsr(OSVW_ID_Length, msr);
 623
 624                 msr = rdmsr(OSVW_Status);
 625                 msr.lo |= 0x01;         /* OS Visible Workaround - MSR */
 626                 wrmsr(OSVW_Status, msr);
 627         }
 628
 629         if (!affectedRev && (mctGetLogicalCPUID(0xFF) & AMD_DR_B3)) {
 630                 msr = rdmsr(OSVW_ID_Length);
 631                 msr.lo |= 0x01;         /* OS Visible Workaround - MSR */
 632                 wrmsr(OSVW_ID_Length, msr);
 633
 634         }
 635 }
 636
 637
 638 u32 get_platform_type(void)
 639 {
 640         u32 ret = 0;
 641
 642         switch(SYSTEM_TYPE) {
 643         case 1:
 644                 ret |= AMD_PTYPE_DSK;
 645                 break;
 646         case 2:
 647                 ret |= AMD_PTYPE_MOB;
 648                 break;
 649         case 0:
 650                 ret |= AMD_PTYPE_SVR;
 651                 break;
 652         default:
 653                 break;
 654         }
 655
 656         /* FIXME: add UMA support. */
 657
 658         /* All Fam10 are multi core */
 659         ret |= AMD_PTYPE_MC;
 660
 661         return ret;
 662 }
 663
 664
 665 /**
 666  * AMD_CpuFindCapability - Traverse PCI capability list to find host HT links.
 667  *  HT Phy operations are not valid on links that aren't present, so this
 668  *  prevents invalid accesses.
 669  *
 670  * Returns the offset of the link register.
 671  */
 672 BOOL AMD_CpuFindCapability (u8 node, u8 cap_count, u8 *offset)
 673 {
 674         u32 val;
 675
 676         /* get start of CPU HT Host Capabilities */
 677         val = pci_read_config32(NODE_PCI(node, 0), 0x34);
 678         val &= 0xFF;
 679
 680         cap_count++;
 681
 682         /* Traverse through the capabilities. */
 683         do {
 684                 val = pci_read_config32(NODE_PCI(node, 0), val);
 685                 /* Is the capability block a HyperTransport capability block? */
 686                 if ((val & 0xFF) == 0x08)
 687                         /* Is the HT capability block an HT Host Capability? */
 688                         if ((val & 0xE0000000) == (1 << 29))
 689                                 cap_count--;
 690                 val = (val >> 8) & 0xFF;
 691         } while (cap_count && val);
 692
 693         *offset = (u8) val;
 694
 695         /* If requested capability found val != 0 */
 696         if (!cap_count)
 697                 return TRUE;
 698         else
 699                 return FALSE;
 700 }
 701
 702
 703 /**
 704  * AMD_checkLinkType - Compare desired link characteristics using a logical
 705  *     link type mask.
 706  *
 707  * Returns the link characteristic mask.
 708  */
 709 u32 AMD_checkLinkType (u8 node, u8 link, u8 regoff)
 710 {
 711         u32 val;
 712         u32 linktype;
 713
 714         /* Check coherency */
 715         val = pci_read_config32(NODE_PCI(node, 0), regoff + 0x18);
 716         val &= 0x1F;
 717
 718         if (val == 3)
 719                 linktype |= HTPHY_LINKTYPE_COHERENT;
 720
 721         if (val == 7)
 722                 linktype |= HTPHY_LINKTYPE_NONCOHERENT;
 723
 724         /* Check gen3 */
 725         val = pci_read_config32(NODE_PCI(node, 0), regoff + 0x08);
 726
 727         if (((val >> 8) & 0x0F) > 6)
 728                 linktype |= HTPHY_LINKTYPE_HT3;
 729         else
 730                 linktype |= HTPHY_LINKTYPE_HT1;
 731
 732
 733         /* Check ganged */
 734         val = pci_read_config32(NODE_PCI(node, 0), (link << 2) + 0x170);
 735
 736         if ( val & 1)
 737                 linktype |= HTPHY_LINKTYPE_GANGED;
 738         else
 739                 linktype |= HTPHY_LINKTYPE_UNGANGED;
 740
 741         return linktype;
 742 }
 743
 744
 745 /**
 746  * AMD_SetHtPhyRegister - Use the HT link's HT Phy portal registers to update
 747  *   a phy setting for that link.
 748  */
 749 void AMD_SetHtPhyRegister (u8 node, u8 link, u8 entry)
 750 {
 751         u32 phyReg;
 752         u32 phyBase;
 753         u32 val;
 754
 755         /* Determine this link's portal */
 756         if (link > 3)
 757                 link -= 4;
 758
 759         phyBase = ((u32)link << 3) | 0x180;
 760
 761
 762         /* Get the portal control register's initial value
 763          * and update it to access the desired phy register
 764          */
 765         phyReg = pci_read_config32(NODE_PCI(node, 4), phyBase);
 766
 767         if (fam10_htphy_default[entry].htreg > 0x1FF) {
 768                 phyReg &= ~HTPHY_DIRECT_OFFSET_MASK;
 769                 phyReg |= HTPHY_DIRECT_MAP;
 770         } else {
 771                 phyReg &= ~HTPHY_OFFSET_MASK;
 772         }
 773
 774         /* Now get the current phy register data
 775          * LinkPhyDone = 0, LinkPhyWrite = 0 is a read
 776          */
 777         phyReg |= fam10_htphy_default[entry].htreg;
 778         pci_write_config32(NODE_PCI(node, 4), phyBase, phyReg);
 779
 780         do {
 781                 val = pci_read_config32(NODE_PCI(node, 4), phyBase);
 782         } while (!(val & HTPHY_IS_COMPLETE_MASK));
 783
 784         /* Now we have the phy register data, apply the change */
 785         val = pci_read_config32(NODE_PCI(node, 4), phyBase + 4);
 786         val &= ~fam10_htphy_default[entry].mask;
 787         val |= fam10_htphy_default[entry].data;
 788         pci_write_config32(NODE_PCI(node, 4), phyBase + 4, val);
 789
 790         /* write it through the portal to the phy
 791          * LinkPhyDone = 0, LinkPhyWrite = 1 is a write
 792          */
 793         phyReg |= HTPHY_WRITE_CMD;
 794         pci_write_config32(NODE_PCI(node, 4), phyBase, phyReg);
 795
 796         do {
 797                 val = pci_read_config32(NODE_PCI(node, 4), phyBase);
 798         } while (!(val & HTPHY_IS_COMPLETE_MASK));
 799 }
 800
 801
 802 void cpuSetAMDMSR(void)
 803 {
 804         /* This routine loads the CPU with default settings in fam10_msr_default
 805          * table . It must be run after Cache-As-RAM has been enabled, and
 806          * Hypertransport initialization has taken place.  Also note
 807          * that it is run on the current processor only, and only for the current
 808          * processor core.
 809          */
 810         msr_t msr;
 811         u8 i;
 812         u32 revision, platform;
 813
 814         printk_debug("cpuSetAMDMSR ");
 815
 816         revision = mctGetLogicalCPUID(0xFF);
 817         platform = get_platform_type();
 818
 819         for(i = 0; i < sizeof(fam10_msr_default)/sizeof(fam10_msr_default[0]); i++) {
 820                 if ((fam10_msr_default[i].revision & revision) &&
 821                     (fam10_msr_default[i].platform & platform)) {
 822                         msr = rdmsr(fam10_msr_default[i].msr);
 823                         msr.hi &= ~fam10_msr_default[i].mask_hi;
 824                         msr.hi |= fam10_msr_default[i].data_hi;
 825                         msr.lo &= ~fam10_msr_default[i].mask_lo;
 826                         msr.lo |= fam10_msr_default[i].data_lo;
 827                         wrmsr(fam10_msr_default[i].msr, msr);
 828                 }
 829         }
 830         AMD_Errata298();
 831
 832         printk_debug(" done\n");
 833 }
 834
 835
 836 void cpuSetAMDPCI(u8 node)
 837 {
 838         /* This routine loads the CPU with default settings in fam10_pci_default
 839          * table . It must be run after Cache-As-RAM has been enabled, and
 840          * Hypertransport initialization has taken place.  Also note
 841          * that it is run for the first core on each node
 842          */
 843         u8 i, j;
 844         u32 revision, platform;
 845         u32 val;
 846         u8 offset;
 847
 848         printk_debug("cpuSetAMDPCI %02d", node);
 849
 850         revision = mctGetLogicalCPUID(node);
 851         platform = get_platform_type();
 852
 853         for(i = 0; i < sizeof(fam10_pci_default)/sizeof(fam10_pci_default[0]); i++) {
 854                 if ((fam10_pci_default[i].revision & revision) &&
 855                     (fam10_pci_default[i].platform & platform)) {
 856                         val = pci_read_config32(NODE_PCI(node,
 857                                 fam10_pci_default[i].function),
 858                                 fam10_pci_default[i].offset);
 859                         val &= ~fam10_pci_default[i].mask;
 860                         val |= fam10_pci_default[i].data;
 861                         pci_write_config32(NODE_PCI(node,
 862                                 fam10_pci_default[i].function),
 863                                 fam10_pci_default[i].offset, val);
 864                 }
 865         }
 866
 867         for(i = 0; i < sizeof(fam10_htphy_default)/sizeof(fam10_htphy_default[0]); i++) {
 868                 if ((fam10_htphy_default[i].revision & revision) &&
 869                     (fam10_htphy_default[i].platform & platform)) {
 870                         /* HT Phy settings either apply to both sublinks or have
 871                          * separate registers for sublink zero and one, so there
 872                          * will be two table entries. So, here we only loop
 873                          cd t   * through the sublink zeros in function zero.
 874                          */
 875                         for (j = 0; j < 4; j++) {
 876                                 if (AMD_CpuFindCapability(node, j, &offset)) {
 877                                         if (AMD_checkLinkType(node, j, offset)
 878                                             & fam10_htphy_default[i].linktype) {
 879                                                 AMD_SetHtPhyRegister(node, j, i);
 880                                         }
 881                                 } else {
 882                                         /* No more capabilities,
 883                                          * link not present
 884                                          */
 885                                         break;
 886                                 }
 887                         }
 888                 }
 889         }
 890
 891         /* FIXME: add UMA support and programXbarToSriReg(); */
 892
 893         AMD_Errata281(node, revision, platform);
 894
 895         /* FIXME: if the dct phy doesn't init correct it needs to reset.
 896         if (revision & (AMD_DR_B2 | AMD_DR_B3))
 897                 dctPhyDiag(); */
 898
 899         printk_debug(" done\n");
 900 }
 901
 902
 903 void cpuInitializeMCA(void)
 904 {
 905         /* Clears Machine Check Architecture (MCA) registers, which power on
 906          * containing unknown data, on currently running processor.
 907          * This routine should only be executed on initial power on (cold boot),
 908          * not across a warm reset because valid data is present at that time.
 909          */
 910
 911         msr_t msr;
 912         u32 reg;
 913         u8 i;
 914
 915         if (cpuid_edx(1) & 0x4080) { /* MCE and MCA (edx[7] and edx[14]) */
 916                 msr = rdmsr(MCG_CAP);
 917                 if (msr.lo & MCG_CTL_P){        /* MCG_CTL_P bit is set? */
 918                         msr.lo &= 0xFF;
 919                         msr.lo--;
 920                         msr.lo <<= 2;           /* multiply the count by 4 */
 921                         reg = MC0_STA + msr.lo;
 922                         msr.lo = msr.hi = 0;
 923                         for (i=0; i < 4; i++) {
 924                                 wrmsr (reg, msr);
 925                                 reg -=4;        /* Touch status regs for each bank */
 926                         }
 927                 }
 928         }
 929 }
 930
 931
 932 /**
 933  * finalize_node_setup()
 934  *
 935  * Do any additional post HT init
 936  *
 937  */
 938 void finalize_node_setup(struct sys_info *sysinfo)
 939 {
 940         u8 i;
 941         u8 nodes = get_nodes();
 942         u32 reg;
 943
 944 #if RAMINIT_SYSINFO == 1
 945         /* read Node0 F0_0x64 bit [8:10] to find out SbLink # */
 946         reg = pci_read_config32(NODE_HT(0), 0x64);
 947         sysinfo->sblk = (reg>>8) & 7;
 948         sysinfo->sbbusn = 0;
 949         sysinfo->nodes = nodes;
 950         sysinfo->sbdn = get_sbdn(sysinfo->sbbusn);
 951 #endif
 952
 953
 954         for (i = 0; i < nodes; i++) {
 955                 cpuSetAMDPCI(i);
 956         }
 957
 958 #if FAM10_SET_FIDVID == 1
 959         // Prep each node for FID/VID setup.
 960         prep_fid_change();
 961 #endif
 962
 963 #if CONFIG_MAX_PHYSICAL_CPUS > 1
 964         /* Skip the BSP, start at node 1 */
 965         for(i=1; i<nodes; i++) {
 966                 setup_remote_node(i);
 967                 start_node(i);
 968         }
 969 #endif
 970 }
 971