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 CONFIG_ENABLE_APIC_EXT_ID and CONFIG_APIC_ID_OFFSET and CONFIG_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 void print_initcpu8 (const char *strval, u8 val)
  34 {
  35         printk_debug("%s%02x\n", strval, val);
  36 }
  37
  38 static void print_initcpu8_nocr (const char *strval, u8 val)
  39 {
  40         printk_debug("%s%02x", strval, val);
  41 }
  42
  43
  44 static void print_initcpu16 (const char *strval, u16 val)
  45 {
  46         printk_debug("%s%04x\n", strval, val);
  47 }
  48
  49
  50 static 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 CONFIG_PCI_IO_CFG_EXT == 1
  62 static 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 CONFIG_PCI_IO_CFG_EXT 4K range
  68         msr.hi |= (1<<(46-32));
  69         wrmsr(NB_CFG_MSR, msr);
  70 }
  71 #else
  72 static 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 void set_pci_mmio_conf_reg(void)
  82 {
  83 #if CONFIG_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+CONFIG_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 (CONFIG_ENABLE_APIC_EXT_ID == 1) && (CONFIG_APIC_ID_OFFSET > 0)
 172                         #if CONFIG_LIFT_BSP_APIC_ID == 0
 173                         if( (i != 0) || (j != 0)) /* except bsp */
 174                         #endif
 175                                 ap_apicid += CONFIG_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 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         msr_t msr;
 299
 300         /* Disable L2 IC to L3 connection (Only for CAR) */
 301         msr = rdmsr(BU_CFG2);
 302         msr.lo &= ~(1 << ClLinesToNbDis);
 303         wrmsr(BU_CFG2, msr);
 304
 305         disable_cache_as_ram(); // inline
 306         stop_this_cpu();
 307 }
 308
 309
 310 #ifndef CONFIG_MEM_TRAIN_SEQ
 311 #define CONFIG_MEM_TRAIN_SEQ 0
 312 #endif
 313
 314 #if RAMINIT_SYSINFO == 1
 315 static u32 init_cpus(u32 cpu_init_detectedx ,struct sys_info *sysinfo)
 316 #else
 317 static u32 init_cpus(u32 cpu_init_detectedx)
 318 #endif
 319 {
 320         u32 bsp_apicid = 0;
 321         u32 apicid;
 322         struct node_core_id id;
 323
 324         /*
 325          * already set early mtrr in cache_as_ram.inc
 326          */
 327
 328         /* enable access pci conf via mmio*/
 329         set_pci_mmio_conf_reg();
 330
 331         /* that is from initial apicid, we need nodeid and coreid
 332            later */
 333         id = get_node_core_id_x();
 334
 335         /* NB_CFG MSR is shared between cores, so we need make sure
 336           core0 is done at first --- use wait_all_core0_started  */
 337         if(id.coreid == 0) {
 338                 set_apicid_cpuid_lo(); /* only set it on core0 */
 339                 set_EnableCf8ExtCfg(); /* only set it on core0 */
 340                 #if (CONFIG_ENABLE_APIC_EXT_ID == 1)
 341                 enable_apic_ext_id(id.nodeid);
 342                 #endif
 343         }
 344
 345         enable_lapic();
 346
 347
 348 #if (CONFIG_ENABLE_APIC_EXT_ID == 1) && (CONFIG_APIC_ID_OFFSET > 0)
 349         u32 initial_apicid = get_initial_apicid();
 350
 351         #if CONFIG_LIFT_BSP_APIC_ID == 0
 352         if( initial_apicid != 0 ) // other than bsp
 353         #endif
 354         {
 355                 /* use initial apic id to lift it */
 356                 u32 dword = lapic_read(LAPIC_ID);
 357                 dword &= ~(0xff << 24);
 358                 dword |= (((initial_apicid + CONFIG_APIC_ID_OFFSET) & 0xff) << 24);
 359
 360                 lapic_write(LAPIC_ID, dword);
 361         }
 362
 363         #if CONFIG_LIFT_BSP_APIC_ID == 1
 364         bsp_apicid += CONFIG_APIC_ID_OFFSET;
 365         #endif
 366
 367 #endif
 368
 369         /* get the apicid, it may be lifted already */
 370         apicid = lapicid();
 371
 372         // show our apicid, nodeid, and coreid
 373         if( id.coreid==0 ) {
 374                 if (id.nodeid!=0) //all core0 except bsp
 375                         print_apicid_nodeid_coreid(apicid, id, " core0: ");
 376         }
 377         else { //all other cores
 378                 print_apicid_nodeid_coreid(apicid, id, " corex: ");
 379         }
 380
 381
 382         if (cpu_init_detectedx) {
 383                 print_apicid_nodeid_coreid(apicid, id, "\n\n\nINIT detected from ");
 384                 print_debug("\nIssuing SOFT_RESET...\n");
 385                 soft_reset();
 386         }
 387
 388         if(id.coreid == 0) {
 389                 if(!(warm_reset_detect(id.nodeid))) //FIXME: INIT is checked above but check for more resets?
 390                         distinguish_cpu_resets(id.nodeid); // Also indicates we are started
 391         }
 392
 393         // Mark the core as started.
 394         lapic_write(LAPIC_MSG_REG, (apicid << 24) | 0x13);
 395
 396
 397         if(apicid != bsp_apicid) {
 398                 /* Setup each AP's cores MSRs.
 399                  * This happens after HTinit.
 400                  * The BSP runs this code in it's own path.
 401                  */
 402                 update_microcode(cpuid_eax(1));
 403                 cpuSetAMDMSR();
 404
 405
 406 #if FAM10_SET_FIDVID == 1
 407         #if (CONFIG_LOGICAL_CPUS == 1)  && (FAM10_SET_FIDVID_CORE0_ONLY == 1)
 408                 // Run on all AP for proper FID/VID setup.
 409                 if(id.coreid == 0 ) // only need set fid for core0
 410         #endif
 411                 {
 412                 // check warm(bios) reset to call stage2 otherwise do stage1
 413                         if (warm_reset_detect(id.nodeid)) {
 414                                 printk_debug("init_fidvid_stage2 apicid: %02x\n", apicid);
 415                                 init_fidvid_stage2(apicid, id.nodeid);
 416                         } else {
 417                                 printk_debug("init_fidvid_ap(stage1) apicid: %02x\n", apicid);
 418                                 init_fidvid_ap(bsp_apicid, apicid, id.nodeid, id.coreid);
 419                         }
 420                 }
 421 #endif
 422
 423                 /* AP is ready, Wait for the BSP to get memory configured */
 424                 /* FIXME: many cores spinning on node0 pci register seems to be bad.
 425                  * Why do we need to wait? These APs are just going to go sit in a hlt.
 426                  */
 427                 //wait_till_sysinfo_in_ram();
 428
 429                 set_init_ram_access();
 430
 431                 STOP_CAR_AND_CPU();
 432                 printk_debug("\nAP %02x should be halted but you are reading this....\n", apicid);
 433         }
 434
 435         return bsp_apicid;
 436 }
 437
 438
 439 static u32 is_core0_started(u32 nodeid)
 440 {
 441         u32 htic;
 442         device_t device;
 443         device = NODE_PCI(nodeid, 0);
 444         htic = pci_read_config32(device, HT_INIT_CONTROL);
 445         htic &= HTIC_ColdR_Detect;
 446         return htic;
 447 }
 448
 449
 450 static void wait_all_core0_started(void)
 451 {
 452         /* When core0 is started, it will distingush_cpu_resets
 453           . So wait for that to finish */
 454         u32 i;
 455         u32 nodes = get_nodes();
 456
 457         printk_debug("Wait all core0s started \n");
 458         for(i=1;i<nodes;i++) { // skip bsp, because it is running on bsp
 459                 while(!is_core0_started(i)) {}
 460                 print_initcpu8("  Core0 started on node: ", i);
 461         }
 462         printk_debug("Wait all core0s started done\n");
 463 }
 464 #if CONFIG_MAX_PHYSICAL_CPUS > 1
 465 /**
 466  * void start_node(u32 node)
 467  *
 468  *  start the core0 in node, so it can generate HT packet to feature code.
 469  *
 470  * This function starts the AP nodes core0s. wait_all_core0_started() in
 471  * cache_as_ram_auto.c waits for all the AP to be finished before continuing
 472  * system init.
 473  */
 474 static void start_node(u8 node)
 475 {
 476         u32 val;
 477
 478         /* Enable routing table */
 479         printk_debug("Start node %02x", node);
 480
 481 #if CONFIG_CAR_FAM10 == 1
 482         /* For CONFIG_CAR_FAM10 support, we need to set Dram base/limit for the new node */
 483         pci_write_config32(NODE_MP(node), 0x44, 0);
 484         pci_write_config32(NODE_MP(node), 0x40, 3);
 485 #endif
 486
 487         /* Allow APs to make requests (ROM fetch) */
 488         val=pci_read_config32(NODE_HT(node), 0x6c);
 489         val &= ~(1 << 1);
 490         pci_write_config32(NODE_HT(node), 0x6c, val);
 491
 492         printk_debug(" done.\n");
 493 }
 494
 495
 496 /**
 497  * static void setup_remote_node(u32 node)
 498  *
 499  * Copy the BSP Adress Map to each AP.
 500  */
 501 static void setup_remote_node(u8 node)
 502 {
 503         /* There registers can be used with F1x114_x Address Map at the
 504            same time, So must set them even 32 node */
 505         static const u16 pci_reg[] = {
 506                 /* DRAM Base/Limits Registers */
 507                 0x44, 0x4c, 0x54, 0x5c, 0x64, 0x6c, 0x74, 0x7c,
 508                 0x40, 0x48, 0x50, 0x58, 0x60, 0x68, 0x70, 0x78,
 509                 0x144, 0x14c, 0x154, 0x15c, 0x164, 0x16c, 0x174, 0x17c,
 510                 0x140, 0x148, 0x150, 0x158, 0x160, 0x168, 0x170, 0x178,
 511                 /* MMIO Base/Limits Registers */
 512                 0x84, 0x8c, 0x94, 0x9c, 0xa4, 0xac, 0xb4, 0xbc,
 513                 0x80, 0x88, 0x90, 0x98, 0xa0, 0xa8, 0xb0, 0xb8,
 514                 /* IO Base/Limits Registers */
 515                 0xc4, 0xcc, 0xd4, 0xdc,
 516                 0xc0, 0xc8, 0xd0, 0xd8,
 517                 /* Configuration Map Registers */
 518                 0xe0, 0xe4, 0xe8, 0xec,
 519         };
 520         u16 i;
 521
 522         printk_debug("setup_remote_node: %02x", node);
 523
 524         /* copy the default resource map from node 0 */
 525         for(i = 0; i < ARRAY_SIZE(pci_reg); i++) {
 526                 u32 value;
 527                 u16 reg;
 528                 reg = pci_reg[i];
 529                 value = pci_read_config32(NODE_MP(0), reg);
 530                 pci_write_config32(NODE_MP(node), reg, value);
 531
 532         }
 533         printk_debug(" done\n");
 534 }
 535 #endif  /* CONFIG_MAX_PHYSICAL_CPUS > 1 */
 536
 537 void AMD_Errata281(u8 node, u32 revision, u32 platform)
 538 {
 539         /* Workaround for Transaction Scheduling Conflict in
 540          * Northbridge Cross Bar.  Implement XCS Token adjustment
 541          * for ganged links.  Also, perform fix up for the mixed
 542          * revision case.
 543          */
 544
 545         u32 reg, val;
 546         u8 i;
 547         u8 mixed = 0;
 548         u8 nodes = get_nodes();
 549
 550         if (platform & AMD_PTYPE_SVR) {
 551                 /* For each node we need to check for a "broken" node */
 552                 if (!(revision & (AMD_DR_B0 | AMD_DR_B1))) {
 553                         for (i = 0; i < nodes; i++) {
 554                                 if (mctGetLogicalCPUID(i) & (AMD_DR_B0 | AMD_DR_B1)) {
 555                                         mixed = 1;
 556                                         break;
 557                                 }
 558                         }
 559                 }
 560
 561                 if ((revision & (AMD_DR_B0 | AMD_DR_B1)) || mixed) {
 562
 563                         /* F0X68[22:21] DsNpReqLmt0 = 01b */
 564                         val = pci_read_config32(NODE_PCI(node, 0), 0x68);
 565                         val &= ~0x00600000;
 566                         val |= 0x00200000;
 567                         pci_write_config32(NODE_PCI(node, 0), 0x68, val);
 568
 569                         /* F3X6C */
 570                         val = pci_read_config32(NODE_PCI(node, 3), 0x6C);
 571                         val &= ~0x700780F7;
 572                         val |= 0x00010094;
 573                         pci_write_config32(NODE_PCI(node, 3), 0x6C, val);
 574
 575                         /* F3X7C */
 576                         val = pci_read_config32(NODE_PCI(node, 3), 0x7C);
 577                         val &= ~0x707FFF1F;
 578                         val |= 0x00144514;
 579                         pci_write_config32(NODE_PCI(node, 3), 0x7C, val);
 580
 581                         /* F3X144[3:0] RspTok = 0001b */
 582                         val = pci_read_config32(NODE_PCI(node, 3), 0x144);
 583                         val &= ~0x0000000F;
 584                         val |= 0x00000001;
 585                         pci_write_config32(NODE_PCI(node, 3), 0x144, val);
 586
 587                         for (i = 0; i < 3; i++) {
 588                                 reg = 0x148 + (i * 4);
 589                                 val = pci_read_config32(NODE_PCI(node, 3), reg);
 590                                 val &= ~0x000000FF;
 591                                 val |= 0x000000DB;
 592                                 pci_write_config32(NODE_PCI(node, 3), reg, val);
 593                         }
 594                 }
 595         }
 596 }
 597
 598
 599 void AMD_Errata298(void)
 600 {
 601         /* Workaround for L2 Eviction May Occur during operation to
 602          * set Accessed or dirty bit.
 603          */
 604
 605         msr_t msr;
 606         u8 i;
 607         u8 affectedRev = 0;
 608         u8 nodes = get_nodes();
 609
 610         /* For each core we need to check for a "broken" node */
 611         for (i = 0; i < nodes; i++) {
 612                 if (mctGetLogicalCPUID(i) & (AMD_DR_B0 | AMD_DR_B1 | AMD_DR_B2)) {
 613                         affectedRev = 1;
 614                         break;
 615                 }
 616         }
 617
 618         if (affectedRev) {
 619                 msr = rdmsr(HWCR);
 620                 msr.lo |= 0x08;         /* Set TlbCacheDis bit[3] */
 621                 wrmsr(HWCR, msr);
 622
 623                 msr = rdmsr(BU_CFG);
 624                 msr.lo |= 0x02;         /* Set TlbForceMemTypeUc bit[1] */
 625                 wrmsr(BU_CFG, msr);
 626
 627                 msr = rdmsr(OSVW_ID_Length);
 628                 msr.lo |= 0x01;         /* OS Visible Workaround - MSR */
 629                 wrmsr(OSVW_ID_Length, msr);
 630
 631                 msr = rdmsr(OSVW_Status);
 632                 msr.lo |= 0x01;         /* OS Visible Workaround - MSR */
 633                 wrmsr(OSVW_Status, msr);
 634         }
 635
 636         if (!affectedRev && (mctGetLogicalCPUID(0xFF) & AMD_DR_B3)) {
 637                 msr = rdmsr(OSVW_ID_Length);
 638                 msr.lo |= 0x01;         /* OS Visible Workaround - MSR */
 639                 wrmsr(OSVW_ID_Length, msr);
 640
 641         }
 642 }
 643
 644
 645 u32 get_platform_type(void)
 646 {
 647         u32 ret = 0;
 648
 649         switch(SYSTEM_TYPE) {
 650         case 1:
 651                 ret |= AMD_PTYPE_DSK;
 652                 break;
 653         case 2:
 654                 ret |= AMD_PTYPE_MOB;
 655                 break;
 656         case 0:
 657                 ret |= AMD_PTYPE_SVR;
 658                 break;
 659         default:
 660                 break;
 661         }
 662
 663         /* FIXME: add UMA support. */
 664
 665         /* All Fam10 are multi core */
 666         ret |= AMD_PTYPE_MC;
 667
 668         return ret;
 669 }
 670
 671
 672 void AMD_SetupPSIVID_d (u32 platform_type, u8 node)
 673 {
 674         u32 dword;
 675         int i;
 676         msr_t msr;
 677
 678         if (platform_type & (AMD_PTYPE_MOB | AMD_PTYPE_DSK)) {
 679
 680         /* The following code sets the PSIVID to the lowest support P state
 681          * assuming that the VID for the lowest power state is below
 682          * the VDD voltage regulator threshold. (This also assumes that there
 683          * is a Pstate lower than P0)
 684          */
 685
 686                 for( i = 4; i >= 0; i--) {
 687                         msr = rdmsr(PS_REG_BASE + i);
 688                         /*  Pstate valid? */
 689                         if (msr.hi & PS_EN_MASK) {
 690                                 dword = pci_read_config32(NODE_PCI(i,3), 0xA0);
 691                                 dword &= ~0x7F;
 692                                 dword |= (msr.lo >> 9) & 0x7F;
 693                                 pci_write_config32(NODE_PCI(i,3), 0xA0, dword);
 694                                 break;
 695                         }
 696                 }
 697         }
 698 }
 699
 700
 701 /**
 702  * AMD_CpuFindCapability - Traverse PCI capability list to find host HT links.
 703  *  HT Phy operations are not valid on links that aren't present, so this
 704  *  prevents invalid accesses.
 705  *
 706  * Returns the offset of the link register.
 707  */
 708 BOOL AMD_CpuFindCapability (u8 node, u8 cap_count, u8 *offset)
 709 {
 710         u32 val;
 711
 712         /* get start of CPU HT Host Capabilities */
 713         val = pci_read_config32(NODE_PCI(node, 0), 0x34);
 714         val &= 0xFF;
 715
 716         cap_count++;
 717
 718         /* Traverse through the capabilities. */
 719         do {
 720                 val = pci_read_config32(NODE_PCI(node, 0), val);
 721                 /* Is the capability block a HyperTransport capability block? */
 722                 if ((val & 0xFF) == 0x08) {
 723                         /* Is the HT capability block an HT Host Capability? */
 724                         if ((val & 0xE0000000) == (1 << 29))
 725                                 cap_count--;
 726                 }
 727                 if (cap_count)
 728                         val = (val >> 8) & 0xFF;
 729         } while (cap_count && val);
 730
 731         *offset = (u8) val;
 732
 733         /* If requested capability found val != 0 */
 734         if (!cap_count)
 735                 return TRUE;
 736         else
 737                 return FALSE;
 738 }
 739
 740
 741 /**
 742  * AMD_checkLinkType - Compare desired link characteristics using a logical
 743  *     link type mask.
 744  *
 745  * Returns the link characteristic mask.
 746  */
 747 u32 AMD_checkLinkType (u8 node, u8 link, u8 regoff)
 748 {
 749         u32 val;
 750         u32 linktype = 0;
 751
 752         /* Check connect, init and coherency */
 753         val = pci_read_config32(NODE_PCI(node, 0), regoff + 0x18);
 754         val &= 0x1F;
 755
 756         if (val == 3)
 757                 linktype |= HTPHY_LINKTYPE_COHERENT;
 758
 759         if (val == 7)
 760                 linktype |= HTPHY_LINKTYPE_NONCOHERENT;
 761
 762         if (linktype) {
 763                 /* Check gen3 */
 764                 val = pci_read_config32(NODE_PCI(node, 0), regoff + 0x08);
 765
 766                 if (((val >> 8) & 0x0F) > 6)
 767                         linktype |= HTPHY_LINKTYPE_HT3;
 768                 else
 769                         linktype |= HTPHY_LINKTYPE_HT1;
 770
 771
 772                 /* Check ganged */
 773                 val = pci_read_config32(NODE_PCI(node, 0), (link << 2) + 0x170);
 774
 775                 if ( val & 1)
 776                         linktype |= HTPHY_LINKTYPE_GANGED;
 777                 else
 778                         linktype |= HTPHY_LINKTYPE_UNGANGED;
 779         }
 780         return linktype;
 781 }
 782
 783
 784 /**
 785  * AMD_SetHtPhyRegister - Use the HT link's HT Phy portal registers to update
 786  *   a phy setting for that link.
 787  */
 788 void AMD_SetHtPhyRegister (u8 node, u8 link, u8 entry)
 789 {
 790         u32 phyReg;
 791         u32 phyBase;
 792         u32 val;
 793
 794         /* Determine this link's portal */
 795         if (link > 3)
 796                 link -= 4;
 797
 798         phyBase = ((u32)link << 3) | 0x180;
 799
 800
 801         /* Get the portal control register's initial value
 802          * and update it to access the desired phy register
 803          */
 804         phyReg = pci_read_config32(NODE_PCI(node, 4), phyBase);
 805
 806         if (fam10_htphy_default[entry].htreg > 0x1FF) {
 807                 phyReg &= ~HTPHY_DIRECT_OFFSET_MASK;
 808                 phyReg |= HTPHY_DIRECT_MAP;
 809         } else {
 810                 phyReg &= ~HTPHY_OFFSET_MASK;
 811         }
 812
 813         /* Now get the current phy register data
 814          * LinkPhyDone = 0, LinkPhyWrite = 0 is a read
 815          */
 816         phyReg |= fam10_htphy_default[entry].htreg;
 817         pci_write_config32(NODE_PCI(node, 4), phyBase, phyReg);
 818
 819         do {
 820                 val = pci_read_config32(NODE_PCI(node, 4), phyBase);
 821         } while (!(val & HTPHY_IS_COMPLETE_MASK));
 822
 823         /* Now we have the phy register data, apply the change */
 824         val = pci_read_config32(NODE_PCI(node, 4), phyBase + 4);
 825         val &= ~fam10_htphy_default[entry].mask;
 826         val |= fam10_htphy_default[entry].data;
 827         pci_write_config32(NODE_PCI(node, 4), phyBase + 4, val);
 828
 829         /* write it through the portal to the phy
 830          * LinkPhyDone = 0, LinkPhyWrite = 1 is a write
 831          */
 832         phyReg |= HTPHY_WRITE_CMD;
 833         pci_write_config32(NODE_PCI(node, 4), phyBase, phyReg);
 834
 835         do {
 836                 val = pci_read_config32(NODE_PCI(node, 4), phyBase);
 837         } while (!(val & HTPHY_IS_COMPLETE_MASK));
 838 }
 839
 840
 841 void cpuSetAMDMSR(void)
 842 {
 843         /* This routine loads the CPU with default settings in fam10_msr_default
 844          * table . It must be run after Cache-As-RAM has been enabled, and
 845          * Hypertransport initialization has taken place.  Also note
 846          * that it is run on the current processor only, and only for the current
 847          * processor core.
 848          */
 849         msr_t msr;
 850         u8 i;
 851         u32 revision, platform;
 852
 853         printk_debug("cpuSetAMDMSR ");
 854
 855         revision = mctGetLogicalCPUID(0xFF);
 856         platform = get_platform_type();
 857
 858         for(i = 0; i < ARRAY_SIZE(fam10_msr_default); i++) {
 859                 if ((fam10_msr_default[i].revision & revision) &&
 860                     (fam10_msr_default[i].platform & platform)) {
 861                         msr = rdmsr(fam10_msr_default[i].msr);
 862                         msr.hi &= ~fam10_msr_default[i].mask_hi;
 863                         msr.hi |= fam10_msr_default[i].data_hi;
 864                         msr.lo &= ~fam10_msr_default[i].mask_lo;
 865                         msr.lo |= fam10_msr_default[i].data_lo;
 866                         wrmsr(fam10_msr_default[i].msr, msr);
 867                 }
 868         }
 869         AMD_Errata298();
 870
 871         printk_debug(" done\n");
 872 }
 873
 874
 875 void cpuSetAMDPCI(u8 node)
 876 {
 877         /* This routine loads the CPU with default settings in fam10_pci_default
 878          * table . It must be run after Cache-As-RAM has been enabled, and
 879          * Hypertransport initialization has taken place.  Also note
 880          * that it is run for the first core on each node
 881          */
 882         u8 i, j;
 883         u32 revision, platform;
 884         u32 val;
 885         u8 offset;
 886
 887         printk_debug("cpuSetAMDPCI %02d", node);
 888
 889
 890         revision = mctGetLogicalCPUID(node);
 891         platform = get_platform_type();
 892
 893         AMD_SetupPSIVID_d(platform, node);      /* Set PSIVID offset which is not table driven */
 894
 895         for(i = 0; i < ARRAY_SIZE(fam10_pci_default); i++) {
 896                 if ((fam10_pci_default[i].revision & revision) &&
 897                     (fam10_pci_default[i].platform & platform)) {
 898                         val = pci_read_config32(NODE_PCI(node,
 899                                 fam10_pci_default[i].function),
 900                                 fam10_pci_default[i].offset);
 901                         val &= ~fam10_pci_default[i].mask;
 902                         val |= fam10_pci_default[i].data;
 903                         pci_write_config32(NODE_PCI(node,
 904                                 fam10_pci_default[i].function),
 905                                 fam10_pci_default[i].offset, val);
 906                 }
 907         }
 908
 909         for(i = 0; i < ARRAY_SIZE(fam10_htphy_default); i++) {
 910                 if ((fam10_htphy_default[i].revision & revision) &&
 911                     (fam10_htphy_default[i].platform & platform)) {
 912                         /* HT Phy settings either apply to both sublinks or have
 913                          * separate registers for sublink zero and one, so there
 914                          * will be two table entries. So, here we only loop
 915                          cd t   * through the sublink zeros in function zero.
 916                          */
 917                         for (j = 0; j < 4; j++) {
 918                                 if (AMD_CpuFindCapability(node, j, &offset)) {
 919                                         if (AMD_checkLinkType(node, j, offset)
 920                                             & fam10_htphy_default[i].linktype) {
 921                                                 AMD_SetHtPhyRegister(node, j, i);
 922                                         }
 923                                 } else {
 924                                         /* No more capabilities,
 925                                          * link not present
 926                                          */
 927                                         break;
 928                                 }
 929                         }
 930                 }
 931         }
 932
 933         /* FIXME: add UMA support and programXbarToSriReg(); */
 934
 935         AMD_Errata281(node, revision, platform);
 936
 937         /* FIXME: if the dct phy doesn't init correct it needs to reset.
 938         if (revision & (AMD_DR_B2 | AMD_DR_B3))
 939                 dctPhyDiag(); */
 940
 941         printk_debug(" done\n");
 942 }
 943
 944
 945 void cpuInitializeMCA(void)
 946 {
 947         /* Clears Machine Check Architecture (MCA) registers, which power on
 948          * containing unknown data, on currently running processor.
 949          * This routine should only be executed on initial power on (cold boot),
 950          * not across a warm reset because valid data is present at that time.
 951          */
 952
 953         msr_t msr;
 954         u32 reg;
 955         u8 i;
 956
 957         if (cpuid_edx(1) & 0x4080) { /* MCE and MCA (edx[7] and edx[14]) */
 958                 msr = rdmsr(MCG_CAP);
 959                 if (msr.lo & MCG_CTL_P){        /* MCG_CTL_P bit is set? */
 960                         msr.lo &= 0xFF;
 961                         msr.lo--;
 962                         msr.lo <<= 2;           /* multiply the count by 4 */
 963                         reg = MC0_STA + msr.lo;
 964                         msr.lo = msr.hi = 0;
 965                         for (i=0; i < 4; i++) {
 966                                 wrmsr (reg, msr);
 967                                 reg -=4;        /* Touch status regs for each bank */
 968                         }
 969                 }
 970         }
 971 }
 972
 973
 974 /**
 975  * finalize_node_setup()
 976  *
 977  * Do any additional post HT init
 978  *
 979  */
 980 void finalize_node_setup(struct sys_info *sysinfo)
 981 {
 982         u8 i;
 983         u8 nodes = get_nodes();
 984         u32 reg;
 985
 986 #if RAMINIT_SYSINFO == 1
 987         /* read Node0 F0_0x64 bit [8:10] to find out SbLink # */
 988         reg = pci_read_config32(NODE_HT(0), 0x64);
 989         sysinfo->sblk = (reg>>8) & 7;
 990         sysinfo->sbbusn = 0;
 991         sysinfo->nodes = nodes;
 992         sysinfo->sbdn = get_sbdn(sysinfo->sbbusn);
 993 #endif
 994
 995
 996         for (i = 0; i < nodes; i++) {
 997                 cpuSetAMDPCI(i);
 998         }
 999
1000 #if FAM10_SET_FIDVID == 1
1001         // Prep each node for FID/VID setup.
1002         prep_fid_change();
1003 #endif
1004
1005 #if CONFIG_MAX_PHYSICAL_CPUS > 1
1006         /* Skip the BSP, start at node 1 */
1007         for(i=1; i<nodes; i++) {
1008                 setup_remote_node(i);
1009                 start_node(i);
1010         }
1011 #endif
1012 }
1013