src/mainboard/supermicro/h8dme/romstage.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  17  */
  18
  19 #define RAMINIT_SYSINFO 1
  20
  21 #define K8_ALLOCATE_IO_RANGE 1
  22
  23 #define QRANK_DIMM_SUPPORT 1
  24
  25 #if CONFIG_LOGICAL_CPUS==1
  26 #define SET_NB_CFG_54 1
  27 #endif
  28
  29 // used by init_cpus and fidvid
  30 #define SET_FIDVID 1
  31 //if we want to wait for core1 done before DQS training, set it to 0
  32 #define SET_FIDVID_CORE0_ONLY 1
  33
  34 #if CONFIG_K8_REV_F_SUPPORT == 1
  35 #define K8_REV_F_SUPPORT_F0_F1_WORKAROUND 0
  36 #endif
  37
  38 #include <stdint.h>
  39 #include <string.h>
  40 #include <device/pci_def.h>
  41 #include <device/pci_ids.h>
  42 #include <arch/io.h>
  43 #include <device/pnp_def.h>
  44 #include <arch/romcc_io.h>
  45 #include <cpu/x86/lapic.h>
  46 #include <pc80/mc146818rtc.h>
  47
  48 #include <console/console.h>
  49 #include <lib.h>
  50
  51 #include <cpu/amd/model_fxx_rev.h>
  52
  53 // for enable the FAN
  54 #include "southbridge/nvidia/mcp55/mcp55_early_smbus.c"
  55 #include "northbridge/amd/amdk8/raminit.h"
  56 #include "cpu/amd/model_fxx/apic_timer.c"
  57 #include "lib/delay.c"
  58
  59 #include "cpu/x86/lapic/boot_cpu.c"
  60 #include "northbridge/amd/amdk8/reset_test.c"
  61 #include "superio/winbond/w83627hf/w83627hf_early_serial.c"
  62 #include "superio/winbond/w83627hf/w83627hf_early_init.c"
  63
  64 #include "cpu/x86/bist.h"
  65
  66 #include "northbridge/amd/amdk8/debug.c"
  67
  68 #include "cpu/x86/mtrr/earlymtrr.c"
  69
  70 #include "northbridge/amd/amdk8/setup_resource_map.c"
  71
  72 #define SERIAL_DEV PNP_DEV(0x2e, W83627HF_SP1)
  73
  74 #include "southbridge/nvidia/mcp55/mcp55_early_ctrl.c"
  75
  76 static void memreset(int controllers, const struct mem_controller *ctrl)
  77 {
  78 }
  79
  80 static inline void dump_smbus_registers(void)
  81 {
  82         u32 device;
  83
  84         print_debug("\n");
  85         for (device = 1; device < 0x80; device++) {
  86                 int j;
  87                 if (smbus_read_byte(device, 0) < 0)
  88                         continue;
  89                 printk(BIOS_DEBUG, "smbus: %02x", device);
  90                 for (j = 0; j < 256; j++) {
  91                         int status;
  92                         unsigned char byte;
  93                         status = smbus_read_byte(device, j);
  94                         if (status < 0) {
  95                                 break;
  96                         }
  97                         if ((j & 0xf) == 0) {
  98                                 printk(BIOS_DEBUG, "\n%02x: ", j);
  99                         }
 100                         byte = status & 0xff;
 101                         printk(BIOS_DEBUG, "%02x ", byte);
 102                 }
 103                 print_debug("\n");
 104         }
 105 }
 106
 107 static inline void activate_spd_rom(const struct mem_controller *ctrl)
 108 {
 109 #if 0
 110 /* We don't do any switching yet. */
 111 #define SMBUS_SWITCH1 0x48
 112 #define SMBUS_SWITCH2 0x49
 113         unsigned device=(ctrl->channel0[0])>>8;
 114         smbus_send_byte(SMBUS_SWITCH1, device);
 115         smbus_send_byte(SMBUS_SWITCH2, (device >> 4) & 0x0f);
 116 #endif
 117 }
 118
 119 #if 0
 120 static int smbus_send_byte_one(unsigned device, unsigned char val)
 121 {
 122         return do_smbus_send_byte(SMBUS1_IO_BASE, device, val);
 123 }
 124
 125 static inline void change_i2c_mux(unsigned device)
 126 {
 127 #define SMBUS_SWITCH1 0x48
 128 #define SMBUS_SWITHC2 0x49
 129         smbus_send_byte(SMBUS_SWITCH1, device & 0x0f);
 130         smbus_send_byte_one(SMBUS_SWITCH2, (device >> 4) & 0x0f);
 131         int ret;
 132         print_debug("change_i2c_mux i="); print_debug_hex8(device); print_debug("\n");
 133         dump_smbus_registers();
 134         ret = smbus_send_byte(SMBUS_SWITCH1, device);
 135         print_debug("change_i2c_mux ret="); print_debug_hex32(ret); print_debug("\n");
 136         dump_smbus_registers();
 137         ret = smbus_send_byte_one(SMBUS_SWITCH2, device);
 138         print_debug("change_i2c_mux ret="); print_debug_hex32(ret); print_debug("\n");
 139         dump_smbus_registers();
 140 }
 141 #endif
 142
 143 static inline int spd_read_byte(unsigned device, unsigned address)
 144 {
 145         return smbus_read_byte(device, address);
 146 }
 147
 148 #include "northbridge/amd/amdk8/amdk8_f.h"
 149 #include "northbridge/amd/amdk8/incoherent_ht.c"
 150 #include "northbridge/amd/amdk8/coherent_ht.c"
 151 #include "northbridge/amd/amdk8/raminit_f.c"
 152 #include "lib/generic_sdram.c"
 153
 154 #include "resourcemap.c"
 155
 156 #include "cpu/amd/dualcore/dualcore.c"
 157
 158 #define MCP55_NUM 1
 159 #define MCP55_USE_NIC 1
 160 #define MCP55_USE_AZA 1
 161
 162 #define MCP55_PCI_E_X_0 4
 163
 164 #include "southbridge/nvidia/mcp55/mcp55_early_setup_ss.h"
 165 #include "southbridge/nvidia/mcp55/mcp55_early_setup_car.c"
 166
 167 #include "cpu/amd/car/post_cache_as_ram.c"
 168
 169 #include "cpu/amd/model_fxx/init_cpus.c"
 170
 171 #include "cpu/amd/model_fxx/fidvid.c"
 172
 173 #include "southbridge/nvidia/mcp55/mcp55_enable_rom.c"
 174 #include "northbridge/amd/amdk8/early_ht.c"
 175
 176 static void sio_setup(void)
 177 {
 178         uint32_t dword;
 179         uint8_t byte;
 180
 181         enable_smbus();
 182 //      smbusx_write_byte(1, (0x58>>1), 0, 0x80); /* select bank0 */
 183         smbusx_write_byte(1, (0x58 >> 1), 0xb1, 0xff);  /* set FAN ctrl to DC mode */
 184
 185         byte = pci_read_config8(PCI_DEV(0, MCP55_DEVN_BASE + 1, 0), 0x7b);
 186         byte |= 0x20;
 187         pci_write_config8(PCI_DEV(0, MCP55_DEVN_BASE + 1, 0), 0x7b, byte);
 188
 189         dword = pci_read_config32(PCI_DEV(0, MCP55_DEVN_BASE + 1, 0), 0xa0);
 190         dword |= (1 << 0);
 191         pci_write_config32(PCI_DEV(0, MCP55_DEVN_BASE + 1, 0), 0xa0, dword);
 192
 193         dword = pci_read_config32(PCI_DEV(0, MCP55_DEVN_BASE + 1, 0), 0xa4);
 194         dword |= (1 << 16);
 195         pci_write_config32(PCI_DEV(0, MCP55_DEVN_BASE + 1, 0), 0xa4, dword);
 196 }
 197
 198 /* We have no idea where the SMBUS switch is. This doesn't do anything ATM. */
 199 #define RC0 (2<<8)
 200 #define RC1 (1<<8)
 201
 202 void cache_as_ram_main(unsigned long bist, unsigned long cpu_init_detectedx)
 203 {
 204 /* The SPD is being read from the CPU1 (marked CPU2 on the board) and we
 205    don't know how to switch the SMBus to decode the CPU0 SPDs. So, The
 206    memory on each CPU must be an exact match.
 207  */
 208         static const uint16_t spd_addr[] = {
 209                 // Node 0
 210                 RC0 | (0xa << 3) | 0, RC0 | (0xa << 3) | 2,
 211                     RC0 | (0xa << 3) | 4, RC0 | (0xa << 3) | 6,
 212                 RC0 | (0xa << 3) | 1, RC0 | (0xa << 3) | 3,
 213                     RC0 | (0xa << 3) | 5, RC0 | (0xa << 3) | 7,
 214                 // Node 1
 215                 RC1 | (0xa << 3) | 0, RC1 | (0xa << 3) | 2,
 216                     RC1 | (0xa << 3) | 4, RC1 | (0xa << 3) | 6,
 217                 RC1 | (0xa << 3) | 1, RC1 | (0xa << 3) | 3,
 218                     RC1 | (0xa << 3) | 5, RC1 | (0xa << 3) | 7,
 219         };
 220
 221         struct sys_info *sysinfo = (struct sys_info *)(CONFIG_DCACHE_RAM_BASE
 222                 + CONFIG_DCACHE_RAM_SIZE - CONFIG_DCACHE_RAM_GLOBAL_VAR_SIZE);
 223
 224         int needs_reset = 0;
 225         unsigned bsp_apicid = 0;
 226
 227         if (!cpu_init_detectedx && boot_cpu()) {
 228                 /* Nothing special needs to be done to find bus 0 */
 229                 /* Allow the HT devices to be found */
 230
 231                 enumerate_ht_chain();
 232
 233                 sio_setup();
 234
 235                 /* Setup the mcp55 */
 236                 mcp55_enable_rom();
 237         }
 238
 239         if (bist == 0) {
 240                 bsp_apicid = init_cpus(cpu_init_detectedx, sysinfo);
 241         }
 242
 243         pnp_enter_ext_func_mode(SERIAL_DEV);
 244         pnp_write_config(SERIAL_DEV, 0x24, 0x84 | (1 << 6));
 245         w83627hf_enable_dev(SERIAL_DEV, CONFIG_TTYS0_BASE);
 246         pnp_exit_ext_func_mode(SERIAL_DEV);
 247
 248         uart_init();
 249         console_init();
 250
 251         /* Halt if there was a built in self test failure */
 252         report_bist_failure(bist);
 253
 254         printk(BIOS_DEBUG, "*sysinfo range: [%p,%p]\n",sysinfo,sysinfo+1);
 255
 256         setup_mb_resource_map();
 257
 258         print_debug("bsp_apicid=");
 259         print_debug_hex8(bsp_apicid);
 260         print_debug("\n");
 261
 262 #if CONFIG_MEM_TRAIN_SEQ == 1
 263         set_sysinfo_in_ram(0);  // in BSP so could hold all ap until sysinfo is in ram
 264 #endif
 265 /*      dump_smbus_registers(); */
 266         setup_coherent_ht_domain();     // routing table and start other core0
 267
 268         wait_all_core0_started();
 269 #if CONFIG_LOGICAL_CPUS==1
 270         // It is said that we should start core1 after all core0 launched
 271         /* becase optimize_link_coherent_ht is moved out from setup_coherent_ht_domain,
 272          * So here need to make sure last core0 is started, esp for two way system,
 273          * (there may be apic id conflicts in that case)
 274          */
 275         start_other_cores();
 276         wait_all_other_cores_started(bsp_apicid);
 277 #endif
 278
 279         /* it will set up chains and store link pair for optimization later */
 280         ht_setup_chains_x(sysinfo);     // it will init sblnk and sbbusn, nodes, sbdn
 281
 282 #if SET_FIDVID == 1
 283
 284         {
 285                 msr_t msr;
 286                 msr = rdmsr(0xc0010042);
 287                 print_debug("begin msr fid, vid ");
 288                 print_debug_hex32(msr.hi);
 289                 print_debug_hex32(msr.lo);
 290                 print_debug("\n");
 291
 292         }
 293
 294         enable_fid_change();
 295
 296         enable_fid_change_on_sb(sysinfo->sbbusn, sysinfo->sbdn);
 297
 298         init_fidvid_bsp(bsp_apicid);
 299
 300         // show final fid and vid
 301         {
 302                 msr_t msr;
 303                 msr = rdmsr(0xc0010042);
 304                 print_debug("end   msr fid, vid ");
 305                 print_debug_hex32(msr.hi);
 306                 print_debug_hex32(msr.lo);
 307                 print_debug("\n");
 308
 309         }
 310 #endif
 311
 312         init_timer(); /* Need to use TMICT to synconize FID/VID. */
 313
 314         needs_reset |= optimize_link_coherent_ht();
 315         needs_reset |= optimize_link_incoherent_ht(sysinfo);
 316         needs_reset |= mcp55_early_setup_x();
 317
 318         // fidvid change will issue one LDTSTOP and the HT change will be effective too
 319         if (needs_reset) {
 320                 print_info("ht reset -\n");
 321                 soft_reset();
 322         }
 323
 324         allow_all_aps_stop(bsp_apicid);
 325
 326         //It's the time to set ctrl in sysinfo now;
 327         fill_mem_ctrl(sysinfo->nodes, sysinfo->ctrl, spd_addr);
 328
 329         enable_smbus();         /* enable in sio_setup */
 330
 331         /* all ap stopped? */
 332
 333         sdram_initialize(sysinfo->nodes, sysinfo->ctrl, sysinfo);
 334
 335         post_cache_as_ram();    // bsp swtich stack to ram and copy sysinfo ram now
 336
 337 }
 338