src/mainboard/via/epia-m700/wakeup.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * Copyright (C) 2008 Rudolf Marek <r.marek@assembler.cz>
   5  * Copyright (C) 2009 One Laptop per Child, Association, Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  20  */
  21
  22 /* Parts of this code is taken from reboot.c from Linux. */
  23
  24 /*
  25  * This file mostly copied from Rudolf's S3 patch, some changes in
  26  * acpi_jump_wake().
  27  */
  28
  29 #include <stdint.h>
  30 #include <string.h>
  31 #include <arch/io.h>
  32 #include <console/console.h>
  33 #include <delay.h>
  34 #include "wakeup.h"
  35
  36 int enable_a20(void);
  37
  38 /*
  39  * The following code and data reboots the machine by switching to real
  40  * mode and jumping to the BIOS reset entry point, as if the CPU has
  41  * really been reset. The previous version asked the keyboard
  42  * controller to pulse the CPU reset line, which is more thorough, but
  43  * doesn't work with at least one type of 486 motherboard. It is easy
  44  * to stop this code working; hence the copious comments.
  45  */
  46
  47 static unsigned long long real_mode_gdt_entries[3] = {
  48         0x0000000000000000ULL,  /* Null descriptor */
  49         0x00009a000000ffffULL,  /* 16-bit real-mode 64k code at 0x00000000 */
  50         0x000092000100ffffULL   /* 16-bit real-mode 64k data at 0x00000100 */
  51 };
  52
  53 struct Xgt_desc_struct {
  54         unsigned short size;
  55         unsigned long address __attribute__ ((packed));
  56         unsigned short pad;
  57 } __attribute__ ((packed));
  58
  59 static struct Xgt_desc_struct real_mode_gdt = {
  60         sizeof(real_mode_gdt_entries) - 1,
  61         (long)real_mode_gdt_entries
  62 },
  63 real_mode_idt = {0x3ff, 0},
  64 no_idt = { 0, 0 };
  65
  66 /*
  67  * This is 16-bit protected mode code to disable paging and the cache,
  68  * switch to real mode and jump to the BIOS reset code.
  69  *
  70  * The instruction that switches to real mode by writing to CR0 must be
  71  * followed immediately by a far jump instruction, which set CS to a
  72  * valid value for real mode, and flushes the prefetch queue to avoid
  73  * running instructions that have already been decoded in protected
  74  * mode.
  75  *
  76  * Clears all the flags except ET, especially PG (paging), PE
  77  * (protected-mode enable) and TS (task switch for coprocessor state
  78  * save). Flushes the TLB after paging has been disabled. Sets CD and
  79  * NW, to disable the cache on a 486, and invalidates the cache. This
  80  * is more like the state of a 486 after reset. I don't know if
  81  * something else should be done for other chips.
  82  *
  83  * More could be done here to set up the registers as if a CPU reset had
  84  * occurred; hopefully real BIOSs don't assume much.
  85  */
  86
  87 //      0x66, 0x0d, 0x00, 0x00, 0x00, 0x60,     /* orl $0x60000000, %eax */
  88
  89 static unsigned char real_mode_switch[] = {
  90         0x66, 0x0f, 0x20, 0xc0,                 /* movl %cr0,%eax */
  91         0x24, 0xfe,                             /* andb $0xfe,al */
  92         0x66, 0x0f, 0x22, 0xc0                  /* movl %eax,%cr0 */
  93 };
  94
  95 static unsigned char jump_to_wakeup[] = {
  96         0xea, 0x00, 0x00, 0x00, 0xe0            /* ljmp $0xffff, $0x0000 */
  97 };
  98
  99 /*
 100  * Switch to real mode and then execute the code
 101  * specified by the code and length parameters.
 102  * We assume that length will aways be less that 100!
 103  */
 104 static unsigned char show31[6] = {
 105         0xb0, 0x31, 0xe6, 0x80, 0xeb, 0xFA      /* ljmp $0xffff, $0x0000 */
 106 };
 107
 108 static unsigned char show32[6] = {
 109         0xb0, 0x32, 0xe6, 0x80, 0xeb, 0xFA      /* ljmp $0xffff, $0x0000 */
 110 };
 111
 112 void acpi_jump_wake(u32 vector)
 113 {
 114         u32 dwEip;
 115         struct Xgt_desc_struct *wake_thunk16_Xgt_desc;
 116
 117         printk(BIOS_DEBUG, "IN ACPI JUMP WAKE TO %x\n", vector);
 118         if (enable_a20())
 119                 die("failed to enable A20\n");
 120         printk(BIOS_DEBUG, "IN ACPI JUMP WAKE TO 3 %x\n", vector);
 121
 122         *((u16 *) (jump_to_wakeup + 3)) = (u16) (vector >> 4);
 123         printk(BIOS_DEBUG, "%x %x %x %x %x\n", jump_to_wakeup[0], jump_to_wakeup[1],
 124                      jump_to_wakeup[2], jump_to_wakeup[3], jump_to_wakeup[4]);
 125
 126         memcpy((void *)(WAKE_THUNK16_ADDR - sizeof(real_mode_switch) - 100),
 127                real_mode_switch, sizeof(real_mode_switch));
 128         memcpy((void *)(WAKE_THUNK16_ADDR - 100), jump_to_wakeup,
 129                sizeof(jump_to_wakeup));
 130
 131         //jason_tsc_count();
 132         printk(BIOS_EMERG, "file '%s', line %d\n\n", __FILE__, __LINE__);
 133         //jason_tsc_count_end();
 134
 135         unsigned long long *real_mode_gdt_entries_at_eseg;
 136         real_mode_gdt_entries_at_eseg = (void *)WAKE_THUNK16_GDT;       /* Copy from real_mode_gdt_entries and change limition to 1M and data base to 0; */
 137         real_mode_gdt_entries_at_eseg[0] = 0x0000000000000000ULL;       /* Null descriptor */
 138         real_mode_gdt_entries_at_eseg[1] = 0x000f9a000000ffffULL;       /* 16-bit real-mode 1M code at 0x00000000 */
 139         real_mode_gdt_entries_at_eseg[2] = 0x000f93000000ffffULL;       /* 16-bit real-mode 1M data at 0x00000000 */
 140
 141         wake_thunk16_Xgt_desc = (void *)WAKE_THUNK16_XDTR;
 142         wake_thunk16_Xgt_desc[0].size = sizeof(real_mode_gdt_entries) - 1;
 143         wake_thunk16_Xgt_desc[0].address = (long)real_mode_gdt_entries_at_eseg;
 144         wake_thunk16_Xgt_desc[1].size = 0x3ff;
 145         wake_thunk16_Xgt_desc[1].address = 0;
 146         wake_thunk16_Xgt_desc[2].size = 0;
 147         wake_thunk16_Xgt_desc[2].address = 0;
 148
 149         /* Added this code to get current value of EIP. */
 150         __asm__ volatile (
 151                 "calll geip\n\t"
 152                 "geip: \n\t"
 153                 "popl %0\n\t"
 154                 : "=a" (dwEip)
 155         );
 156
 157         unsigned char *dest, *src;
 158         src = (unsigned char *)dwEip;
 159         dest = (void *)WAKE_RECOVER1M_CODE;
 160         u32 i;
 161         for (i = 0; i < 0x200; i++)
 162                 dest[i] = src[i];
 163
 164         __asm__ __volatile__("ljmp $0x0010,%0"  /* 08 error */
 165                              ::"i"((void *)(WAKE_RECOVER1M_CODE + 0x20)));
 166
 167         /* Added 0x20 "nop" to make sure the ljmp will not jump then halt. */
 168         asm volatile ("nop");
 169         asm volatile ("nop");
 170         asm volatile ("nop");
 171         asm volatile ("nop");
 172         asm volatile ("nop");
 173         asm volatile ("nop");
 174         asm volatile ("nop");
 175         asm volatile ("nop");
 176         asm volatile ("nop");
 177         asm volatile ("nop");
 178
 179         asm volatile ("nop");
 180         asm volatile ("nop");
 181         asm volatile ("nop");
 182         asm volatile ("nop");
 183         asm volatile ("nop");
 184         asm volatile ("nop");
 185         asm volatile ("nop");
 186         asm volatile ("nop");
 187         asm volatile ("nop");
 188         asm volatile ("nop");
 189
 190         asm volatile ("nop");
 191         asm volatile ("nop");
 192         asm volatile ("nop");
 193         asm volatile ("nop");
 194         asm volatile ("nop");
 195         asm volatile ("nop");
 196         asm volatile ("nop");
 197         asm volatile ("nop");
 198         asm volatile ("nop");
 199         asm volatile ("nop");
 200
 201         __asm__ volatile (
 202                 /*
 203                  * Set new esp, maybe ebp should not equal to esp?, due to the
 204                  * variable in acpi_jump_wake?, anyway, this may be not a big
 205                  * problem. and I didn't clear the area (ef000+-0x200) to zero.
 206                  */
 207                 "movl %0, %%ebp\n\t"
 208                 "movl %0, %%esp\n\t"::"a" (WAKE_THUNK16_STACK)
 209         );
 210
 211         /*
 212          * Only "src" and "dest" use the new stack, and the esp maybe also
 213          * used in resumevector.
 214          */
 215 #if PAYLOAD_IS_SEABIOS == 1
 216         /* WAKE_MEM_INFO inited in get_set_top_available_mem in tables.c. */
 217         src =
 218             (unsigned char *)((*(u32 *) WAKE_MEM_INFO) - 64 * 1024 - 0x100000);
 219         dest = 0;
 220
 221         /*
 222          * If recovered 0-e0000, then when resume, before WinXP turn on the
 223          * desktop screen, there is gray background which last 1sec.
 224          */
 225         for (i = 0; i < 0xa0000; i++)
 226                 dest[i] = src[i];
 227
 228 #if 0
 229         __asm__ volatile (
 230                 "movl %0, %%esi\n\t"
 231                 "movl $0, %%edi\n\t"
 232                 "movl $0xa0000, %%ecx\n\t"
 233                 "shrl $2, %%ecx\n\t"
 234                 "rep movsd\n\t"
 235                 ::"a"(src)
 236         );
 237 #endif
 238         src = (unsigned char *)((*(u32 *) WAKE_MEM_INFO) - 64 * 1024
 239                         - 0x100000 + 0xc0000);
 240
 241 #if 0
 242         dest = 0xc0000;
 243         for (i = 0; i < 0x20000; i++)
 244               dest[i] = src[i];
 245
 246         __asm__ volatile (
 247                 "movl %0, %%esi\n\t"
 248                 "movl $0xc0000, %%edi\n\t"
 249                 "movl $0x20000, %%ecx\n\t"
 250                 "shrl $2, %%ecx\n\t"
 251                 "rep movsd\n\t"
 252                 ::"a"(src)
 253         );
 254 #endif
 255
 256         src = (unsigned char *)((*(u32 *) WAKE_MEM_INFO) - 64 * 1024
 257                         - 0x100000 + 0xe0000 + WAKE_SPECIAL_SIZE);
 258
 259         /* dest = 0xf0000; */
 260         /* for (i = 0; i < 0x10000; i++) */
 261         /*      dest[i] = src[i]; */
 262         __asm__ volatile (
 263                 "movl %0, %%esi\n\t"
 264                 "movl %1, %%edi\n\t"
 265                 "movl %2, %%ecx\n\t"
 266                 "shrl $2, %%ecx\n\t"
 267                 "rep movsd\n\t"::"r" (src),
 268                 "r"(0xe0000 + WAKE_SPECIAL_SIZE),
 269                 "r"(0x10000 - WAKE_SPECIAL_SIZE)
 270         );
 271
 272         src = (unsigned char *)((*(u32 *) WAKE_MEM_INFO) - 64 * 1024
 273                         - 0x100000 + 0xf0000);
 274         /* dest = 0xf0000; */
 275         /* for (i = 0; i < 0x10000; i++) */
 276         /*      dest[i] = src[i]; */
 277         __asm__ volatile (
 278                 "movl %0, %%esi\n\t"
 279                 "movl $0xf0000, %%edi\n\t"
 280                 "movl $0x10000, %%ecx\n\t"
 281                 "shrl $2, %%ecx\n\t" "rep movsd\n\t"::"a" (src)
 282         );
 283
 284         asm volatile ("wbinvd");
 285 #endif
 286         /* Set up the IDT for real mode. */
 287         asm volatile ("lidt %0"::"m" (wake_thunk16_Xgt_desc[1]));
 288
 289         /*
 290          * Set up a GDT from which we can load segment descriptors for real
 291          * mode. The GDT is not used in real mode; it is just needed here to
 292          * prepare the descriptors.
 293          */
 294         asm volatile ("lgdt %0"::"m" (wake_thunk16_Xgt_desc[0]));
 295
 296         /*
 297          * Load the data segment registers, and thus the descriptors ready for
 298          * real mode.  The base address of each segment is 0x100, 16 times the
 299          * selector value being loaded here.  This is so that the segment
 300          * registers don't have to be reloaded after switching to real mode:
 301          * the values are consistent for real mode operation already.
 302          */
 303         __asm__ __volatile__(
 304                 "movl $0x0010,%%eax\n"
 305                 "\tmovl %%eax,%%ds\n"
 306                 "\tmovl %%eax,%%es\n"
 307                 "\tmovl %%eax,%%fs\n"
 308                 "\tmovl %%eax,%%gs\n"
 309                 "\tmovl %%eax,%%ss":::"eax"
 310         );
 311
 312         /*
 313          * Jump to the 16-bit code that we copied earlier. It disables paging
 314          * and the cache, switches to real mode, and jumps to the BIOS reset
 315          * entry point.
 316          */
 317
 318         __asm__ __volatile__(
 319                 "ljmp $0x0008,%0"::"i"
 320                 ((void *)(WAKE_THUNK16_ADDR - sizeof(real_mode_switch) - 100))
 321         );
 322 }
 323
 324 /* -*- linux-c -*- ------------------------------------------------------- *
 325  *
 326  *   Copyright (C) 1991, 1992 Linus Torvalds
 327  *   Copyright 2007 rPath, Inc. - All Rights Reserved
 328  *
 329  *   This file is part of the Linux kernel, and is made available under
 330  *   the terms of the GNU General Public License version 2.
 331  *
 332  * ----------------------------------------------------------------------- */
 333
 334 /*
 335  * arch/i386/boot/a20.c
 336  *
 337  * Enable A20 gate (return -1 on failure)
 338  */
 339
 340 // #include "boot.h"
 341
 342 #define MAX_8042_LOOPS  100000
 343
 344 static int empty_8042(void)
 345 {
 346         u8 status;
 347         int loops = MAX_8042_LOOPS;
 348
 349         while (loops--) {
 350                 udelay(1);
 351
 352                 status = inb(0x64);
 353                 if (status & 1) {
 354                         /* Read and discard input data */
 355                         udelay(1);
 356                         (void)inb(0x60);
 357                 } else if (!(status & 2)) {
 358                         /* Buffers empty, finished! */
 359                         return 0;
 360                 }
 361         }
 362
 363         return -1;
 364 }
 365
 366 /* Returns nonzero if the A20 line is enabled.  The memory address
 367    used as a test is the int $0x80 vector, which should be safe. */
 368
 369 #define A20_TEST_ADDR   (4*0x80)
 370 #define A20_TEST_SHORT  32
 371 #define A20_TEST_LONG   2097152 /* 2^21 */
 372
 373 static int a20_test(int loops)
 374 {
 375         int ok = 0;
 376         int saved, ctr;
 377
 378 //      set_fs(0x0000);
 379 //      set_gs(0xffff);
 380
 381         saved = ctr = *((u32 *) A20_TEST_ADDR);
 382
 383         while (loops--) {
 384                 //wrfs32(++ctr, A20_TEST_ADDR);
 385
 386                 *((u32 *) A20_TEST_ADDR) = ++ctr;
 387
 388                 udelay(1);      /* Serialize and make delay constant */
 389
 390                 ok = *((u32 *) A20_TEST_ADDR + 0xffff0 + 0x10) ^ ctr;
 391                 if (ok)
 392                         break;
 393         }
 394
 395         *((u32 *) A20_TEST_ADDR) = saved;
 396         return ok;
 397 }
 398
 399 /* Quick test to see if A20 is already enabled */
 400 static int a20_test_short(void)
 401 {
 402         return a20_test(A20_TEST_SHORT);
 403 }
 404
 405 /* Longer test that actually waits for A20 to come on line; this
 406    is useful when dealing with the KBC or other slow external circuitry. */
 407 static int a20_test_long(void)
 408 {
 409         return a20_test(A20_TEST_LONG);
 410 }
 411
 412 static void enable_a20_kbc(void)
 413 {
 414         empty_8042();
 415
 416         outb(0xd1, 0x64);       /* Command write */
 417         empty_8042();
 418
 419         outb(0xdf, 0x60);       /* A20 on */
 420         empty_8042();
 421 }
 422
 423 static void enable_a20_fast(void)
 424 {
 425         u8 port_a;
 426
 427         port_a = inb(0x92);     /* Configuration port A */
 428         port_a |= 0x02;         /* Enable A20 */
 429         port_a &= ~0x01;        /* Do not reset machine */
 430         outb(port_a, 0x92);
 431 }
 432
 433 /*
 434  * Actual routine to enable A20; return 0 on ok, -1 on failure
 435  */
 436
 437 #define A20_ENABLE_LOOPS 255    /* Number of times to try */
 438
 439 int enable_a20(void)
 440 {
 441         int loops = A20_ENABLE_LOOPS;
 442
 443         while (loops--) {
 444                 /* First, check to see if A20 is already enabled
 445                    (legacy free, etc.) */
 446                 if (a20_test_short())
 447                         return 0;
 448
 449                 /* Try enabling A20 through the keyboard controller */
 450                 empty_8042();
 451
 452                 // if (a20_test_short())
 453                 //      return 0; /* BIOS worked, but with delayed reaction */
 454
 455                 enable_a20_kbc();
 456                 if (a20_test_long())
 457                         return 0;
 458
 459                 /* Finally, try enabling the "fast A20 gate" */
 460                 enable_a20_fast();
 461                 if (a20_test_long())
 462                         return 0;
 463         }
 464
 465         return -1;
 466 }