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