src/northbridge/via/vx800/examples/romstage.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * Copyright (C) 2009 One Laptop per Child, Association, 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; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  19  */
  20
  21 #define ASSEMBLY 1
  22 #define __PRE_RAM__
  23
  24 #include <stdint.h>
  25 #include <device/pci_def.h>
  26 #include <device/pci_ids.h>
  27 #include <arch/io.h>
  28 #include <device/pnp_def.h>
  29 #include <arch/romcc_io.h>
  30 #include <arch/hlt.h>
  31 #include "pc80/serial.c"
  32 #include "console/console.c"
  33 #include "lib/ramtest.c"
  34 #include "northbridge/via/vx800/vx800.h"
  35 #include "cpu/x86/mtrr/earlymtrr.c"
  36 #include "cpu/x86/bist.h"
  37 #include "pc80/udelay_io.c"
  38 #include "lib/delay.c"
  39 #include "lib/memcpy.c"
  40 #include "cpu/x86/lapic/boot_cpu.c"
  41 #include "driving_clk_phase_data.c"
  42 #include "northbridge/via/vx800/raminit.h"
  43 #include "northbridge/via/vx800/raminit.c"
  44
  45 static int acpi_is_wakeup_early_via_vx800(void)
  46 {
  47         device_t dev;
  48         u16 tmp, result;
  49
  50         print_debug("In acpi_is_wakeup_early_via_vx800\n");
  51         /* Power management controller */
  52         dev = pci_locate_device(PCI_ID(PCI_VENDOR_ID_VIA,
  53                                        PCI_DEVICE_ID_VIA_VX855_LPC), 0);
  54
  55         if (dev == PCI_DEV_INVALID)
  56                 die("Power management controller not found\n");
  57
  58         /* Set ACPI base address to I/O VX800_ACPI_IO_BASE. */
  59         pci_write_config16(dev, 0x88, VX800_ACPI_IO_BASE | 0x1);
  60
  61         /* Enable ACPI accessm RTC signal gated with PSON. */
  62         pci_write_config8(dev, 0x81, 0x84);
  63
  64         tmp = inw(VX800_ACPI_IO_BASE + 0x04);
  65         result = ((tmp & (7 << 10)) >> 10) == 1 ? 3 : 0;
  66         print_debug("         boot_mode=");
  67         print_debug_hex16(result);
  68         print_debug("\n");
  69         return result;
  70 }
  71
  72 static inline int spd_read_byte(unsigned device, unsigned address)
  73 {
  74         return smbus_read_byte(device, address);
  75 }
  76
  77 static void enable_mainboard_devices(void)
  78 {
  79         device_t dev;
  80         uint16_t values;
  81
  82         print_debug("In enable_mainboard_devices \n");
  83
  84         /*
  85            Enable P2P Bridge Header for External PCI BUS.
  86          */
  87         dev = pci_locate_device(PCI_ID(0x1106, 0xa353), 0);
  88         pci_write_config8(dev, 0x4f, 0x41);
  89 }
  90
  91 static void enable_shadow_ram(void)
  92 {
  93         uint8_t shadowreg;
  94         pci_write_config8(PCI_DEV(0, 0, 3), 0x80, 0xff);
  95         /* 0xf0000-0xfffff - ACPI tables */
  96         shadowreg = pci_read_config8(PCI_DEV(0, 0, 3), 0x83);
  97         shadowreg |= 0x30;
  98         pci_write_config8(PCI_DEV(0, 0, 3), 0x83, shadowreg);
  99         /* 0xe0000-0xeffff - elfload? */
 100
 101         pci_write_config8(PCI_DEV(0, 0, 3), 0x82, 0xff);
 102 }
 103
 104 /*
 105 this table contains the value needed to be set before begin to init dram.
 106 Note: REV_Bx should be cared when porting a new board!!!!! */
 107 static const struct VIA_PCI_REG_INIT_TABLE mNbStage1InitTbl[] = {
 108         //VT3409 no pcie
 109         0x00, 0xFF, NB_APIC_REG(0x61), 0xFF, 0x0E,      // Set Exxxxxxx as pcie mmio config range
 110         0x00, 0xFF, NB_APIC_REG(0x60), 0xF4, 0x0B,      // Support extended cfg address of pcie
 111         //0x00, 0xFF, NB_APIC_REG(0x42), 0xF9, 0x02, // APIC Interrupt((BT_INTR)) Control
 112         // Set ROMSIP value by software
 113
 114         /*0x00, 0xFF, NB_HOST_REG(0x70), 0x77, 0x33, // 2x Host Adr Strobe/Pad Pullup Driving = 3
 115            0x00, 0xFF, NB_HOST_REG(0x71), 0x77, 0x33, // 2x Host Adr Strobe/Pad Pulldown Driving = 3
 116            0x00, 0xFF, NB_HOST_REG(0x72), 0x77, 0x33, // 4x Host Dat Strobe/Pad Pullup Driving = 3
 117            0x00, 0xFF, NB_HOST_REG(0x73), 0x77, 0x33, // 4x Host Dat Strobe/Pad Pulldown Driving = 3
 118            0x00, 0xFF, NB_HOST_REG(0x74), 0xFF, 0x21, // Memory I/F timing ctrl
 119            0x00, 0xFF, NB_HOST_REG(0x74), 0xFF, 0xE1, // Memory I/F timing ctrl
 120            0x00, 0xFF, NB_HOST_REG(0x75), 0xFF, 0x18, // AGTL+ I/O Circuit
 121            0x00, 0xFF, NB_HOST_REG(0x76), 0xFB, 0x0C, // AGTL+ Compensation Status
 122            0x00, 0xFF, NB_HOST_REG(0x78), 0xFF, 0x33, // 2X AGTL+ Auto Compensation Offset
 123            0x00, 0xFF, NB_HOST_REG(0x79), 0xFF, 0x33, // 4X AGTL+ Auto Compensation Offset
 124            0x00, 0xFF, NB_HOST_REG(0x7A), 0x3F, 0x72, // AGTL Compensation Status
 125            0x00, 0xFF, NB_HOST_REG(0x7A), 0x3F, 0x77, // AGTL Compensation Status
 126            0x00, 0xFF, NB_HOST_REG(0x7B), 0xFF, 0x44, // Input Host Address / Host Strobe Delay Control for HA Group
 127            0x00, 0xFF, NB_HOST_REG(0x7B), 0xFF, 0x22, // Input Host Address / Host Strobe Delay Control for HA Group
 128            0x00, 0xFF, NB_HOST_REG(0x7C), 0xFF, 0x00, // Output Delay Control of PAD for HA Group
 129            0x00, 0xFF, NB_HOST_REG(0x7D), 0xFF, 0xAA, // Host Address / Address Clock Output Delay Control (Only for P4 Bus)
 130            0x00, 0xFF, NB_HOST_REG(0x7E), 0xFF, 0x10, // Host Address CKG Rising / Falling Time Control (Only for P4 Bus)
 131            0x00, 0xFF, NB_HOST_REG(0x7E), 0xFF, 0x40, // Host Address CKG Rising / Falling Time Control (Only for P4 Bus)
 132            0x00, 0xFF, NB_HOST_REG(0x7F), 0xFF, 0x10, // Host Address CKG Rising / Falling Time Control (Only for P4 Bus)
 133            0x00, 0xFF, NB_HOST_REG(0x7F), 0xFF, 0x40, // Host Address CKG Rising / Falling Time Control (Only for P4 Bus)
 134            0x00, 0xFF, NB_HOST_REG(0x80), 0x3F, 0x44, // Host Data Receiving Strobe Delay Ctrl 1
 135            0x00, 0xFF, NB_HOST_REG(0x81), 0xFF, 0x44, // Host Data Receiving Strobe Delay Ctrl 2
 136            0x00, 0xFF, NB_HOST_REG(0x82), 0xFF, 0x00, // Output Delay of PAD for HDSTB
 137            0x00, 0xFF, NB_HOST_REG(0x83), 0xFF, 0x00, // Output Delay of PAD for HD
 138            0x00, 0xFF, NB_HOST_REG(0x84), 0xFF, 0x44, // Host Data / Strobe CKG Control (Group 0)
 139            0x00, 0xFF, NB_HOST_REG(0x85), 0xFF, 0x44, // Host Data / Strobe CKG Control (Group 1)
 140            0x00, 0xFF, NB_HOST_REG(0x86), 0xFF, 0x44, // Host Data / Strobe CKG Control (Group 2)
 141            0x00, 0xFF, NB_HOST_REG(0x87), 0xFF, 0x44, // Host Data / Strobe CKG Control (Group 3) */
 142
 143
 144         // CPU Host Bus Control
 145         0x00, 0xFF, NB_HOST_REG(0x50), 0x1F, 0x08,      // Request phase ctrl: Dynamic Defer Snoop Stall Count = 8
 146         //0x00, 0xFF, NB_HOST_REG(0x51), 0xFF, 0x7F, // CPU I/F Ctrl-1: Disable Fast DRDY and RAW
 147         0x00, 0xFF, NB_HOST_REG(0x51), 0xFF, 0x7C,      // CPU I/F Ctrl-1: Disable Fast DRDY and RAW
 148         0x00, 0xFF, NB_HOST_REG(0x52), 0xCB, 0xCB,      // CPU I/F Ctrl-2: Enable all for performance
 149         //0x00, 0xFF, NB_HOST_REG(0x53), 0xFF, 0x88, // Arbitration: Host/Master Occupancy timer = 8*4 HCLK
 150         0x00, 0xFF, NB_HOST_REG(0x53), 0xFF, 0x44,      // Arbitration: Host/Master Occupancy timer = 4*4 HCLK
 151         0x00, 0xFF, NB_HOST_REG(0x54), 0x1E, 0x1C,      // Misc Ctrl: Enable 8QW burst Mem Access
 152         //0x00, 0xFF, NB_HOST_REG(0x55), 0x06, 0x06, // Miscellaneous Control 2
 153         0x00, 0xFF, NB_HOST_REG(0x55), 0x06, 0x04,      // Miscellaneous Control 2
 154         0x00, 0xFF, NB_HOST_REG(0x56), 0xF7, 0x63,      // Write Policy 1
 155         //0x00, 0xFF, NB_HOST_REG(0x59), 0x3D, 0x01, // CPU Miscellaneous Control 1, enable Lowest-Priority IPL
 156         //0x00, 0xFF, NB_HOST_REG(0x5c), 0xFF, 0x00, // CPU Miscellaneous Control 2
 157         0x00, 0xFF, NB_HOST_REG(0x5D), 0xFF, 0xA2,      // Write Policy
 158         0x00, 0xFF, NB_HOST_REG(0x5E), 0xFF, 0x88,      // Bandwidth Timer
 159         0x00, 0xFF, NB_HOST_REG(0x5F), 0x46, 0x46,      // CPU Misc Ctrl
 160         // 0x00, 0xFF, NB_HOST_REG(0x90), 0xFF, 0x0B, // CPU Miscellaneous Control 3
 161         //0x00, 0xFF, NB_HOST_REG(0x96), 0x0B, 0x0B, // CPU Miscellaneous Control 2
 162         0x00, 0xFF, NB_HOST_REG(0x96), 0x0B, 0x0A,      // CPU Miscellaneous Control 2
 163         0x00, 0xFF, NB_HOST_REG(0x98), 0xC1, 0x41,      // CPU Miscellaneous Control 3
 164         0x00, 0xFF, NB_HOST_REG(0x99), 0x0E, 0x06,      // CPU Miscellaneous Control 4
 165
 166
 167         // Set APIC and SMRAM
 168         0x00, 0xFF, NB_HOST_REG(0x97), 0xFF, 0x00,      // APIC Related Control
 169         0x00, 0xFF, NB_DRAMC_REG(0x86), 0xD6, 0x29,     // SMM and APIC Decoding: enable APIC, MSI and SMRAM A-Seg
 170         0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // End of the table
 171 };
 172
 173 #define USE_VCP     1           //0 means use DVP
 174 #define USE_COM1    1
 175 #define USE_COM2    0
 176
 177 #define gCom1Base   0x3f8
 178 #define gCom2Base   0x2f8
 179
 180 void EmbedComInit(void)
 181 {
 182         u8 ByteVal;
 183         u16 ComBase;
 184
 185         //enable NB multiple function control
 186         ByteVal = pci_read_config8(PCI_DEV(0, 0, 0), 0x4f);
 187         ByteVal = ByteVal | 0x01;
 188         pci_write_config8(PCI_DEV(0, 0, 0), 0x4f, ByteVal);
 189
 190         //VGA Enable
 191         ByteVal = pci_read_config8(PCI_DEV(0, 0, 3), 0xA1);
 192         ByteVal = ByteVal | 0x80;
 193         pci_write_config8(PCI_DEV(0, 0, 3), 0xA1, ByteVal);
 194
 195         ByteVal = pci_read_config8(PCI_DEV(0, 0, 3), 0xA7);
 196         ByteVal = ByteVal | 0x08;
 197         pci_write_config8(PCI_DEV(0, 0, 3), 0xA7, ByteVal);
 198
 199         //Enable p2p  IO/mem
 200         ByteVal = pci_read_config8(PCI_DEV(0, 1, 0), 0x4);
 201         ByteVal = ByteVal | 0x07;
 202         pci_write_config8(PCI_DEV(0, 1, 0), 0x4, ByteVal);
 203
 204         //Turn on Graphic chip IO port port access
 205         ByteVal = inb(0x3C3);
 206         ByteVal = ByteVal | 0x01;
 207         outb(ByteVal, 0x3C3);
 208
 209         //Turn off Graphic chip Register protection
 210         outb(0x10, 0x3C4);
 211         ByteVal = inb(0x3C5);
 212         ByteVal = ByteVal | 0x01;
 213         outb(ByteVal, 0x3C5);
 214
 215         //south module pad share enable 0x3C5.78[7]
 216         outb(0x78, 0x3C4);
 217         ByteVal = inb(0x3C5);
 218         ByteVal = ByteVal | 0x80;
 219         outb(ByteVal, 0x3C5);
 220
 221         //enable  UART Function multiplex with DVP or VCP pad D17F0Rx46[7,6]
 222         ByteVal = pci_read_config8(PCI_DEV(0, 17, 0), 0x46);
 223         //multiplex with VCP
 224         if (USE_VCP == 1)
 225                 ByteVal = (ByteVal & 0x3F) | 0x40;
 226         //multiplex with DVP
 227         else
 228                 ByteVal = (ByteVal & 0x3F) | 0xC0;
 229         pci_write_config8(PCI_DEV(0, 17, 0), 0x46, ByteVal);
 230
 231         //enable embeded com1 and com2 D17F0RxB0[5,4]
 232         ByteVal = pci_read_config8(PCI_DEV(0, 17, 0), 0xB0);
 233         ByteVal = ByteVal & 0xcf;
 234         //multiplex with VCP
 235         if (USE_COM1 == 1)
 236                 ByteVal = ByteVal | 0x10;
 237         if (USE_COM2 == 1)
 238                 ByteVal = ByteVal | 0x20;
 239         pci_write_config8(PCI_DEV(0, 17, 0), 0xB0, ByteVal);
 240
 241         if (USE_COM1 == 1)
 242                 ComBase = gCom1Base;
 243         else
 244                 ComBase = gCom2Base;
 245
 246 //noharddrive
 247
 248         //set embeded com1 IO base = 0x3E8
 249         //D17F0RB4
 250         //ByteVal = 0xFD;
 251         if (USE_COM1 == 1) {
 252                 ByteVal = (u8) ((gCom1Base >> 3) | 0x80);
 253                 pci_write_config8(PCI_DEV(0, 17, 0), 0xB4, ByteVal);
 254                 ByteVal = pci_read_config8(PCI_DEV(0, 17, 0), 0xb2);
 255                 ByteVal = (ByteVal & 0xf0) | 0x04;
 256                 pci_write_config8(PCI_DEV(0, 17, 0), 0xB2, ByteVal);
 257         }
 258         //set embeded com2 IO base = 0x2E8
 259         //D17F0RB5
 260         //ByteVal = 0xDD;
 261         if (USE_COM2 == 1) {
 262                 ByteVal = (u8) ((gCom2Base >> 3) | 0x80);
 263                 pci_write_config8(PCI_DEV(0, 17, 0), 0xB5, ByteVal);
 264                 ByteVal = pci_read_config8(PCI_DEV(0, 17, 0), 0xb2);
 265                 ByteVal = (ByteVal & 0x0f) | 0x30;
 266                 pci_write_config8(PCI_DEV(0, 17, 0), 0xB2, ByteVal);
 267         }
 268         //no port 80 biger then 0x10
 269
 270         //disable interrupt
 271         ByteVal = inb(ComBase + 3);
 272         outb(ByteVal & 0x7F, ComBase + 3);
 273         outb(0x00, ComBase + 1);
 274
 275         //set baudrate
 276         ByteVal = inb(ComBase + 3);
 277         outb(ByteVal | 0x80, ComBase + 3);
 278         outb(0x01, ComBase);
 279         outb(0x00, ComBase + 1);
 280
 281         //set  frame  fromat
 282         ByteVal = inb(ComBase + 3);
 283         outb(ByteVal & 0x3F, ComBase + 3);
 284         outb(0x03, ComBase + 3);
 285         outb(0x00, ComBase + 2);
 286         outb(0x00, ComBase + 4);
 287
 288         //SOutput("Embeded com output\n");
 289         //while(1);
 290 }
 291
 292 void main(unsigned long bist)
 293 {
 294         unsigned cpu_reset = 0;
 295         u16 boot_mode;
 296         u8 rambits;
 297
 298         //device_t dev;
 299         /* Enable multifunction for northbridge. */
 300         pci_write_config8(PCI_DEV(0, 0, 0), 0x4f, 0x01);
 301         EmbedComInit();
 302         //enable_vx800_serial();
 303         //uart_init();
 304
 305 /*      1.    D15F0
 306
 307 a)      RxBAh = 71h
 308
 309 b)      RxBBh = 05h
 310
 311 c)      RxBEh = 71h
 312
 313 d)      RxBFh = 05h
 314
 315 2.    D17F0
 316
 317 a)      RxA0h = 06h
 318
 319 b)      RxA1h = 11h
 320
 321 c)      RxA2h = 27h
 322
 323 d)      RxA3h = 32h
 324
 325 e)      Rx79h = 40h
 326
 327 f)      Rx72h = 27h
 328
 329 g)      Rx73h = 32h
 330 */
 331
 332         u8 Data8;
 333
 334         pci_write_config16(PCI_DEV(0, 0xf, 0), 0xBA,
 335                            PCI_DEVICE_ID_VIA_VX855_IDE);
 336         pci_write_config16(PCI_DEV(0, 0xf, 0), 0xBE,
 337                            PCI_DEVICE_ID_VIA_VX855_IDE);
 338         pci_write_config16(PCI_DEV(0, 0x11, 0), 0xA0, PCI_VENDOR_ID_VIA);
 339         pci_write_config16(PCI_DEV(0, 0x11, 0), 0xA2,
 340                            PCI_DEVICE_ID_VIA_VX855_LPC);
 341         Data8 = pci_read_config8(PCI_DEV(0, 0x11, 0), 0x79);
 342         Data8 &= ~0x40;
 343         Data8 |= 0x40;
 344         pci_write_config8(PCI_DEV(0, 0x11, 0), 0x79, Data8);
 345         pci_write_config16(PCI_DEV(0, 0x11, 0), 0x72,
 346                            PCI_DEVICE_ID_VIA_VX855_LPC);
 347
 348         console_init();         //there are to function defination of console_init(), while the src/archi386/lib is the right one
 349
 350         /* decide if this is a s3 wakeup or a normal boot */
 351         boot_mode = acpi_is_wakeup_early_via_vx800();
 352         /*add this, to transfer "cpu restart" to "cold boot"
 353            When this boot is not a S3 resume, and PCI registers had been written,
 354            then this must be a cpu restart(result of os reboot cmd). so we need a real "cold boot". */
 355         if ((boot_mode != 3)
 356             && (pci_read_config8(PCI_DEV(0, 0, 3), 0x80) != 0)) {
 357                 outb(6, 0xcf9);
 358         }
 359
 360         /*x86 cold boot I/O cmd */
 361         enable_smbus();
 362         //smbus_fixup(&ctrl);// this fix does help vx800!, but vx855 no need this
 363
 364         if (bist == 0) {
 365                 // CAR need mtrr untill mem is ok, so i disable this early_mtrr_init();
 366                 //print_debug("doing early_mtrr\n");
 367                 //early_mtrr_init();
 368         }
 369
 370         /* Halt if there was a built-in self test failure. */
 371         report_bist_failure(bist);
 372
 373         print_debug("Enabling mainboard devices\n");
 374         enable_mainboard_devices();
 375
 376         u8 Data;
 377         device_t device;
 378         /* Get NB Chip revision from D0F4RxF6, revision will be used in via_pci_inittable */
 379         device = PCI_DEV(0, 0, 4);
 380         Data = pci_read_config8(device, 0xf6);
 381         print_debug("NB chip revision =");
 382         print_debug_hex8(Data);
 383         print_debug("\n");
 384         /* make NB ready before draminit */
 385         via_pci_inittable(Data, mNbStage1InitTbl);
 386
 387         /*add this.
 388            When resume from s3, draminit is skiped, so need to recovery any PCI register related to draminit.
 389            and d0f3 didnt lost its Power during whole s3 time, so any register not belongs to d0f3 need to be recoveried . */
 390 #if 1
 391         if (boot_mode == 3) {
 392                 u8 i;
 393                 u8 ramregs[] = { 0x43, 0x42, 0x41, 0x40 };
 394                 DRAM_SYS_ATTR DramAttr;
 395
 396                 print_debug("This is a S3 wakeup\n");
 397
 398                 memset(&DramAttr, 0, sizeof(DRAM_SYS_ATTR));
 399                 /*Step1 DRAM Detection; DDR1 or DDR2; Get SPD Data; Rank Presence;64 or 128bit; Unbuffered or registered; 1T or 2T */
 400                 DRAMDetect(&DramAttr);
 401
 402                 /*begin to get ram size, 43,42 41 40 contains the end address of last rank in ddr2-slot */
 403                 device = PCI_DEV(0, 0, 3);
 404                 for (rambits = 0, i = 0; i < ARRAY_SIZE(ramregs); i++) {
 405                         rambits = pci_read_config8(device, ramregs[i]);
 406                         if (rambits != 0)
 407                                 break;
 408                 }
 409
 410                 DRAMDRDYSetting(&DramAttr);
 411
 412                 Data = 0x80;    // this value is same with dev_init.c
 413                 pci_write_config8(PCI_DEV(0, 0, 4), 0xa3, Data);
 414                 pci_write_config8(PCI_DEV(0, 17, 7), 0x60, rambits << 2);
 415                 Data = pci_read_config8(MEMCTRL, 0x88);
 416                 pci_write_config8(PCI_DEV(0, 17, 7), 0xE5, Data);
 417
 418                 DRAMRegFinalValue(&DramAttr);   // I just copy this function from draminit to here!
 419                 SetUMARam();    // I just copy this function from draminit to here!
 420                 print_debug("Resume from S3, RAM init was ignored\n");
 421         } else {
 422                 ddr2_ram_setup();
 423                 ram_check(0, 640 * 1024);
 424         }
 425 #endif
 426         //ddr2_ram_setup();
 427         /*this line is the same with cx700 port . */
 428         enable_shadow_ram();
 429
 430         /*
 431            For coreboot most time of S3 resume is the same as normal boot, so some memory area under 1M become dirty,
 432            so before this happen, I need to backup the content of mem to top-mem.
 433            I will reserve the 1M top-men in LBIO table in coreboot_table.c and recovery the content of 1M-mem in wakeup.c
 434          */
 435 #if PAYLOAD_IS_SEABIOS==1       //
 436         if (boot_mode == 3) {
 437                 /*   some idea of Libo.Feng at amd.com in  http://www.coreboot.org/pipermail/coreboot/2008-December/043111.html
 438                    I want move the 1M data, I have to set some MTRRs myself. */
 439                 /* seting mtrr before back memoy save s3 resume time about 0.14 seconds */
 440                 /*because CAR stack use cache, and here to use cache , must be careful,
 441                    1 during these mtrr code, must no function call, (after this mtrr, I think it should be ok to use function)
 442                    2 before stack switch, no use variable that have value set before this
 443                    3 due to 2, take care of "cpu_reset", I directlly set it to ZERO.
 444                  */
 445                 u32 memtop = *(u32 *) WAKE_MEM_INFO;
 446                 u32 memtop1 = *(u32 *) WAKE_MEM_INFO - 0x100000;
 447                 u32 memtop2 = *(u32 *) WAKE_MEM_INFO - 0x200000;
 448                 u32 memtop3 =
 449                     *(u32 *) WAKE_MEM_INFO - 64 * 1024 - 0x100000;
 450                 u32 memtop4 =
 451                     *(u32 *) WAKE_MEM_INFO - 64 * 1024 - 0x100000 +
 452                     0xe0000;
 453                 /*      __asm__ volatile (
 454                    "movl    $0x204, %%ecx\n\t"
 455                    "xorl    %%edx, %%edx\n\t"
 456                    "movl     %0,%%eax\n\t"
 457                    "orl     $(0 | 6), %%eax\n\t"
 458                    "wrmsr\n\t"
 459
 460                    "movl    $0x205, %%ecx\n\t"
 461                    "xorl    %%edx, %%edx\n\t"
 462                    "movl   $0x100000,%%eax\n\t"
 463                    "decl                %%eax\n\t"
 464                    "notl                %%eax\n\t"
 465                    "orl    $(0 | 0x800), %%eax\n\t"
 466                    "wrmsr\n\t"
 467                    ::"g"(memtop2)
 468                    );
 469                    __asm__ volatile (
 470                    "movl    $0x206, %%ecx\n\t"
 471                    "xorl    %%edx, %%edx\n\t"
 472                    "movl     %0,%%eax\n\t"
 473                    "orl     $(0 | 6), %%eax\n\t"
 474                    "wrmsr\n\t"
 475
 476                    "movl    $0x207, %%ecx\n\t"
 477                    "xorl    %%edx, %%edx\n\t"
 478                    "movl   $0x100000,%%eax\n\t"
 479                    "decl                %%eax\n\t"
 480                    "notl                %%eax\n\t"
 481                    "orl    $(0 | 0x800), %%eax\n\t"
 482                    "wrmsr\n\t"
 483                    ::"g"(memtop1)
 484                    );
 485                    __asm__ volatile (
 486                    "movl    $0x208, %ecx\n\t"
 487                    "xorl    %edx, %edx\n\t"
 488                    "movl    $0,%eax\n\t"
 489                    "orl     $(0 | 6), %eax\n\t"
 490                    "wrmsr\n\t"
 491
 492                    "movl    $0x209, %ecx\n\t"
 493                    "xorl    %edx, %edx\n\t"
 494                    "movl     $0x100000,%eax\n\t"
 495                    "decl                %eax\n\t"
 496                    "notl                %eax\n\t"
 497                    "orl     $(0 | 0x800), %eax\n\t"
 498                    "wrmsr\n\t"
 499                    );
 500                  */
 501                 // WAKE_MEM_INFO is  inited in get_set_top_available_mem in tables.c
 502                 // these two memcpy not not be enabled if set the MTRR around this two lines.
 503                 /*__asm__ volatile (
 504                                 "movl    $0, %%esi\n\t"
 505         "movl    %0, %%edi\n\t"
 506         "movl    $0xa0000, %%ecx\n\t"
 507         "shrl    $2, %%ecx\n\t"
 508         "rep movsd\n\t"
 509         ::"g"(memtop3)
 510         );
 511         __asm__ volatile (
 512                                 "movl    $0xe0000, %%esi\n\t"
 513         "movl    %0, %%edi\n\t"
 514         "movl    $0x20000, %%ecx\n\t"
 515         "shrl    $2, %%ecx\n\t"
 516         "rep movsd\n\t"
 517         ::"g"(memtop4)
 518         );*/
 519                 print_debug("copy memory to high memory to protect s3 wakeup vector code \n");  //this can have function call, because no variable used before this
 520                 memcpy((unsigned char *) ((*(u32 *) WAKE_MEM_INFO) -
 521                                           64 * 1024 - 0x100000),
 522                        (unsigned char *) 0, 0xa0000);
 523                 memcpy((unsigned char *) ((*(u32 *) WAKE_MEM_INFO) -
 524                                           64 * 1024 - 0x100000 + 0xe0000),
 525                        (unsigned char *) 0xe0000, 0x20000);
 526
 527                 /* restore the MTRR previously modified. */
 528 /*              __asm__ volatile (
 529         "wbinvd\n\t"
 530         "xorl    %edx, %edx\n\t"
 531         "xorl    %eax, %eax\n\t"
 532         "movl    $0x204, %ecx\n\t"
 533         "wrmsr\n\t"
 534                                 "movl    $0x205, %ecx\n\t"
 535         "wrmsr\n\t"
 536                                 "movl    $0x206, %ecx\n\t"
 537         "wrmsr\n\t"
 538                                 "movl    $0x207, %ecx\n\t"
 539         "wrmsr\n\t"
 540                                 "movl    $0x208, %ecx\n\t"
 541         "wrmsr\n\t"
 542                                 "movl    $0x209, %ecx\n\t"
 543         "wrmsr\n\t"
 544                 );*/
 545         }
 546 #endif
 547 }