180028Stakawata/*- 280028Stakawata * Copyright (c) 2001 Takanori Watanabe <takawata@jp.freebsd.org> 380028Stakawata * Copyright (c) 2001 Mitsuru IWASAKI <iwasaki@jp.freebsd.org> 4189903Sjkim * Copyright (c) 2003 Peter Wemm 5232076Sjkim * Copyright (c) 2008-2012 Jung-uk Kim <jkim@FreeBSD.org> 680028Stakawata * All rights reserved. 780028Stakawata * 880028Stakawata * Redistribution and use in source and binary forms, with or without 980028Stakawata * modification, are permitted provided that the following conditions 1080028Stakawata * are met: 1180028Stakawata * 1. Redistributions of source code must retain the above copyright 1280028Stakawata * notice, this list of conditions and the following disclaimer. 1380028Stakawata * 2. Redistributions in binary form must reproduce the above copyright 1480028Stakawata * notice, this list of conditions and the following disclaimer in the 1580028Stakawata * documentation and/or other materials provided with the distribution. 1680028Stakawata * 1780028Stakawata * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 1880028Stakawata * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1980028Stakawata * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 2080028Stakawata * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 2180028Stakawata * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 2280028Stakawata * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2380028Stakawata * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2480028Stakawata * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2580028Stakawata * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2680028Stakawata * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2780028Stakawata * SUCH DAMAGE. 2880028Stakawata */ 29118030Sobrien 30118030Sobrien#include <sys/cdefs.h> 31118030Sobrien__FBSDID("$FreeBSD$"); 32118030Sobrien 3380028Stakawata#include <sys/param.h> 3480028Stakawata#include <sys/bus.h> 35232082Sjkim#include <sys/eventhandler.h> 36189903Sjkim#include <sys/kernel.h> 37189903Sjkim#include <sys/malloc.h> 38189903Sjkim#include <sys/memrange.h> 39189903Sjkim#include <sys/smp.h> 4080028Stakawata 41189903Sjkim#include <vm/vm.h> 42189903Sjkim#include <vm/pmap.h> 43189903Sjkim 44232082Sjkim#include <machine/clock.h> 45189903Sjkim#include <machine/intr_machdep.h> 46214630Sjhb#include <x86/mca.h> 47189903Sjkim#include <machine/pcb.h> 48189903Sjkim#include <machine/pmap.h> 49189903Sjkim#include <machine/specialreg.h> 50231979Skib#include <machine/md_var.h> 51189903Sjkim 52189903Sjkim#ifdef SMP 53214631Sjhb#include <x86/apicreg.h> 54189903Sjkim#include <machine/smp.h> 55197863Sjkim#include <machine/vmparam.h> 56189903Sjkim#endif 57189903Sjkim 58193530Sjkim#include <contrib/dev/acpica/include/acpi.h> 59193530Sjkim 6080028Stakawata#include <dev/acpica/acpivar.h> 6180028Stakawata 62189903Sjkim#include "acpi_wakecode.h" 63189903Sjkim#include "acpi_wakedata.h" 64189903Sjkim 65189903Sjkim/* Make sure the code is less than a page and leave room for the stack. */ 66189903SjkimCTASSERT(sizeof(wakecode) < PAGE_SIZE - 1024); 67189903Sjkim 68190341Sjkimextern int acpi_resume_beep; 69190341Sjkimextern int acpi_reset_video; 70189903Sjkim 71189903Sjkim#ifdef SMP 72210777Sjkimextern struct pcb **susppcbs; 73231979Skibextern void **suspfpusave; 74189903Sjkim#else 75210777Sjkimstatic struct pcb **susppcbs; 76231979Skibstatic void **suspfpusave; 77189903Sjkim#endif 78189903Sjkim 79247881Savg#ifdef SMP 80247881Savgstatic cpuset_t suspcpus; 81247881Savg#endif 82247881Savg 83232077Sjkimint acpi_restorecpu(uint64_t, vm_offset_t); 84189903Sjkim 85197863Sjkimstatic void *acpi_alloc_wakeup_handler(void); 86189903Sjkimstatic void acpi_stop_beep(void *); 87189903Sjkim 88189903Sjkim#ifdef SMP 89189903Sjkimstatic int acpi_wakeup_ap(struct acpi_softc *, int); 90222813Sattiliostatic void acpi_wakeup_cpus(struct acpi_softc *, const cpuset_t *); 91189903Sjkim#endif 92189903Sjkim 93189903Sjkim#define WAKECODE_VADDR(sc) ((sc)->acpi_wakeaddr + (3 * PAGE_SIZE)) 94189903Sjkim#define WAKECODE_PADDR(sc) ((sc)->acpi_wakephys + (3 * PAGE_SIZE)) 95189903Sjkim#define WAKECODE_FIXUP(offset, type, val) do { \ 96189903Sjkim type *addr; \ 97189903Sjkim addr = (type *)(WAKECODE_VADDR(sc) + offset); \ 98189903Sjkim *addr = val; \ 99189903Sjkim} while (0) 100189903Sjkim 101189903Sjkimstatic void 102189903Sjkimacpi_stop_beep(void *arg) 103189903Sjkim{ 104232082Sjkim 105232082Sjkim if (acpi_resume_beep != 0) 106232082Sjkim timer_spkr_release(); 107189903Sjkim} 108189903Sjkim 109189903Sjkim#ifdef SMP 110189903Sjkimstatic int 111189903Sjkimacpi_wakeup_ap(struct acpi_softc *sc, int cpu) 112189903Sjkim{ 113189903Sjkim int vector = (WAKECODE_PADDR(sc) >> 12) & 0xff; 114189903Sjkim int apic_id = cpu_apic_ids[cpu]; 115189903Sjkim int ms; 116189903Sjkim 117210777Sjkim WAKECODE_FIXUP(wakeup_pcb, struct pcb *, susppcbs[cpu]); 118231979Skib WAKECODE_FIXUP(wakeup_fpusave, void *, suspfpusave[cpu]); 119210777Sjkim WAKECODE_FIXUP(wakeup_gdt, uint16_t, susppcbs[cpu]->pcb_gdt.rd_limit); 120189903Sjkim WAKECODE_FIXUP(wakeup_gdt + 2, uint64_t, 121210777Sjkim susppcbs[cpu]->pcb_gdt.rd_base); 122189903Sjkim WAKECODE_FIXUP(wakeup_cpu, int, cpu); 123189903Sjkim 124189903Sjkim /* do an INIT IPI: assert RESET */ 125189903Sjkim lapic_ipi_raw(APIC_DEST_DESTFLD | APIC_TRIGMOD_EDGE | 126189903Sjkim APIC_LEVEL_ASSERT | APIC_DESTMODE_PHY | APIC_DELMODE_INIT, apic_id); 127189903Sjkim 128189903Sjkim /* wait for pending status end */ 129189903Sjkim lapic_ipi_wait(-1); 130189903Sjkim 131189903Sjkim /* do an INIT IPI: deassert RESET */ 132189903Sjkim lapic_ipi_raw(APIC_DEST_ALLESELF | APIC_TRIGMOD_LEVEL | 133189903Sjkim APIC_LEVEL_DEASSERT | APIC_DESTMODE_PHY | APIC_DELMODE_INIT, 0); 134189903Sjkim 135189903Sjkim /* wait for pending status end */ 136189903Sjkim DELAY(10000); /* wait ~10mS */ 137189903Sjkim lapic_ipi_wait(-1); 138189903Sjkim 139189903Sjkim /* 140189903Sjkim * next we do a STARTUP IPI: the previous INIT IPI might still be 141189903Sjkim * latched, (P5 bug) this 1st STARTUP would then terminate 142189903Sjkim * immediately, and the previously started INIT IPI would continue. OR 143189903Sjkim * the previous INIT IPI has already run. and this STARTUP IPI will 144189903Sjkim * run. OR the previous INIT IPI was ignored. and this STARTUP IPI 145189903Sjkim * will run. 146189903Sjkim */ 147189903Sjkim 148189903Sjkim /* do a STARTUP IPI */ 149189903Sjkim lapic_ipi_raw(APIC_DEST_DESTFLD | APIC_TRIGMOD_EDGE | 150189903Sjkim APIC_LEVEL_DEASSERT | APIC_DESTMODE_PHY | APIC_DELMODE_STARTUP | 151189903Sjkim vector, apic_id); 152189903Sjkim lapic_ipi_wait(-1); 153189903Sjkim DELAY(200); /* wait ~200uS */ 154189903Sjkim 155189903Sjkim /* 156189903Sjkim * finally we do a 2nd STARTUP IPI: this 2nd STARTUP IPI should run IF 157189903Sjkim * the previous STARTUP IPI was cancelled by a latched INIT IPI. OR 158189903Sjkim * this STARTUP IPI will be ignored, as only ONE STARTUP IPI is 159189903Sjkim * recognized after hardware RESET or INIT IPI. 160189903Sjkim */ 161189903Sjkim 162189903Sjkim lapic_ipi_raw(APIC_DEST_DESTFLD | APIC_TRIGMOD_EDGE | 163189903Sjkim APIC_LEVEL_DEASSERT | APIC_DESTMODE_PHY | APIC_DELMODE_STARTUP | 164189903Sjkim vector, apic_id); 165189903Sjkim lapic_ipi_wait(-1); 166189903Sjkim DELAY(200); /* wait ~200uS */ 167189903Sjkim 168189903Sjkim /* Wait up to 5 seconds for it to start. */ 169189903Sjkim for (ms = 0; ms < 5000; ms++) { 170189903Sjkim if (*(int *)(WAKECODE_VADDR(sc) + wakeup_cpu) == 0) 171189903Sjkim return (1); /* return SUCCESS */ 172189903Sjkim DELAY(1000); 173189903Sjkim } 174189903Sjkim return (0); /* return FAILURE */ 175189903Sjkim} 176189903Sjkim 177189903Sjkim#define WARMBOOT_TARGET 0 178189903Sjkim#define WARMBOOT_OFF (KERNBASE + 0x0467) 179189903Sjkim#define WARMBOOT_SEG (KERNBASE + 0x0469) 180189903Sjkim 181189903Sjkim#define CMOS_REG (0x70) 182189903Sjkim#define CMOS_DATA (0x71) 183189903Sjkim#define BIOS_RESET (0x0f) 184189903Sjkim#define BIOS_WARM (0x0a) 185189903Sjkim 186189903Sjkimstatic void 187222813Sattilioacpi_wakeup_cpus(struct acpi_softc *sc, const cpuset_t *wakeup_cpus) 188189903Sjkim{ 189189903Sjkim uint32_t mpbioswarmvec; 190189903Sjkim int cpu; 191189903Sjkim u_char mpbiosreason; 192189903Sjkim 193189903Sjkim /* save the current value of the warm-start vector */ 194189903Sjkim mpbioswarmvec = *((uint32_t *)WARMBOOT_OFF); 195189903Sjkim outb(CMOS_REG, BIOS_RESET); 196189903Sjkim mpbiosreason = inb(CMOS_DATA); 197189903Sjkim 198189903Sjkim /* setup a vector to our boot code */ 199189903Sjkim *((volatile u_short *)WARMBOOT_OFF) = WARMBOOT_TARGET; 200189903Sjkim *((volatile u_short *)WARMBOOT_SEG) = WAKECODE_PADDR(sc) >> 4; 201189903Sjkim outb(CMOS_REG, BIOS_RESET); 202189903Sjkim outb(CMOS_DATA, BIOS_WARM); /* 'warm-start' */ 203189903Sjkim 204189903Sjkim /* Wake up each AP. */ 205189903Sjkim for (cpu = 1; cpu < mp_ncpus; cpu++) { 206222813Sattilio if (!CPU_ISSET(cpu, wakeup_cpus)) 207189903Sjkim continue; 208189903Sjkim if (acpi_wakeup_ap(sc, cpu) == 0) { 209189903Sjkim /* restore the warmstart vector */ 210189903Sjkim *(uint32_t *)WARMBOOT_OFF = mpbioswarmvec; 211189903Sjkim panic("acpi_wakeup: failed to resume AP #%d (PHY #%d)", 212189903Sjkim cpu, cpu_apic_ids[cpu]); 213189903Sjkim } 214189903Sjkim } 215189903Sjkim 216189903Sjkim /* restore the warmstart vector */ 217189903Sjkim *(uint32_t *)WARMBOOT_OFF = mpbioswarmvec; 218189903Sjkim 219189903Sjkim outb(CMOS_REG, BIOS_RESET); 220189903Sjkim outb(CMOS_DATA, mpbiosreason); 221189903Sjkim} 222189903Sjkim#endif 223189903Sjkim 22480028Stakawataint 22580028Stakawataacpi_sleep_machdep(struct acpi_softc *sc, int state) 22680028Stakawata{ 227189903Sjkim ACPI_STATUS status; 228189903Sjkim 229189903Sjkim if (sc->acpi_wakeaddr == 0ul) 230247881Savg return (-1); /* couldn't alloc wake memory */ 231189903Sjkim 232189903Sjkim#ifdef SMP 233247881Savg suspcpus = all_cpus; 234247881Savg CPU_CLR(PCPU_GET(cpuid), &suspcpus); 235189903Sjkim#endif 236189903Sjkim 237232082Sjkim if (acpi_resume_beep != 0) 238232082Sjkim timer_spkr_acquire(); 239232082Sjkim 240189903Sjkim AcpiSetFirmwareWakingVector(WAKECODE_PADDR(sc)); 241189903Sjkim 242189903Sjkim intr_suspend(); 243189903Sjkim 244210777Sjkim if (savectx(susppcbs[0])) { 245262981Sjkim fpususpend(suspfpusave[0]); 246189903Sjkim#ifdef SMP 247247881Savg if (!CPU_EMPTY(&suspcpus) && 248247881Savg suspend_cpus(suspcpus) == 0) { 249222813Sattilio device_printf(sc->acpi_dev, "Failed to suspend APs\n"); 250247881Savg return (0); /* couldn't sleep */ 251189903Sjkim } 252189903Sjkim#endif 253189903Sjkim 254190341Sjkim WAKECODE_FIXUP(resume_beep, uint8_t, (acpi_resume_beep != 0)); 255190341Sjkim WAKECODE_FIXUP(reset_video, uint8_t, (acpi_reset_video != 0)); 256189903Sjkim 257210777Sjkim WAKECODE_FIXUP(wakeup_pcb, struct pcb *, susppcbs[0]); 258231979Skib WAKECODE_FIXUP(wakeup_fpusave, void *, suspfpusave[0]); 259189903Sjkim WAKECODE_FIXUP(wakeup_gdt, uint16_t, 260210777Sjkim susppcbs[0]->pcb_gdt.rd_limit); 261189903Sjkim WAKECODE_FIXUP(wakeup_gdt + 2, uint64_t, 262210777Sjkim susppcbs[0]->pcb_gdt.rd_base); 263189903Sjkim WAKECODE_FIXUP(wakeup_cpu, int, 0); 264189903Sjkim 265189903Sjkim /* Call ACPICA to enter the desired sleep state */ 266189903Sjkim if (state == ACPI_STATE_S4 && sc->acpi_s4bios) 267189903Sjkim status = AcpiEnterSleepStateS4bios(); 268189903Sjkim else 269189903Sjkim status = AcpiEnterSleepState(state); 270189903Sjkim 271189903Sjkim if (status != AE_OK) { 272189903Sjkim device_printf(sc->acpi_dev, 273189903Sjkim "AcpiEnterSleepState failed - %s\n", 274189903Sjkim AcpiFormatException(status)); 275247881Savg return (0); /* couldn't sleep */ 276189903Sjkim } 277189903Sjkim 278189903Sjkim for (;;) 279189903Sjkim ia32_pause(); 280247881Savg } 281247881Savg 282247881Savg return (1); /* wakeup successfully */ 283247881Savg} 284247881Savg 285247881Savgint 286247881Savgacpi_wakeup_machdep(struct acpi_softc *sc, int state, 287247881Savg int sleep_result, int intr_enabled) 288247881Savg{ 289247881Savg 290247881Savg if (sleep_result == -1) 291247881Savg return (sleep_result); 292247881Savg 293247881Savg if (intr_enabled == 0) { 294247881Savg /* Wakeup MD procedures in interrupt disabled context */ 295247881Savg if (sleep_result == 1) { 296247881Savg pmap_init_pat(); 297247881Savg load_cr3(susppcbs[0]->pcb_cr3); 298247881Savg initializecpu(); 299247881Savg PCPU_SET(switchtime, 0); 300247881Savg PCPU_SET(switchticks, ticks); 301189903Sjkim#ifdef SMP 302247881Savg if (!CPU_EMPTY(&suspcpus)) 303247881Savg acpi_wakeup_cpus(sc, &suspcpus); 304189903Sjkim#endif 305247881Savg } 306189903Sjkim 307189903Sjkim#ifdef SMP 308247881Savg if (!CPU_EMPTY(&suspcpus)) 309247881Savg restart_cpus(suspcpus); 310189903Sjkim#endif 311247881Savg mca_resume(); 312247881Savg intr_resume(); 313247881Savg } else { 314247881Savg /* Wakeup MD procedures in interrupt enabled context */ 315247881Savg AcpiSetFirmwareWakingVector(0); 316189903Sjkim 317247881Savg if (sleep_result == 1 && mem_range_softc.mr_op != NULL && 318247881Savg mem_range_softc.mr_op->reinit != NULL) 319247881Savg mem_range_softc.mr_op->reinit(&mem_range_softc); 320247881Savg } 321189903Sjkim 322247881Savg return (sleep_result); 32380028Stakawata} 32480028Stakawata 325197863Sjkimstatic void * 326189903Sjkimacpi_alloc_wakeup_handler(void) 327189903Sjkim{ 328189903Sjkim void *wakeaddr; 329198931Sjkim int i; 330189903Sjkim 331189903Sjkim /* 332189903Sjkim * Specify the region for our wakeup code. We want it in the low 1 MB 333197863Sjkim * region, excluding real mode IVT (0-0x3ff), BDA (0x400-0x4ff), EBDA 334197863Sjkim * (less than 128KB, below 0xa0000, must be excluded by SMAP and DSDT), 335197863Sjkim * and ROM area (0xa0000 and above). The temporary page tables must be 336197863Sjkim * page-aligned. 337189903Sjkim */ 338232085Sjkim wakeaddr = contigmalloc(4 * PAGE_SIZE, M_DEVBUF, M_WAITOK, 0x500, 339197863Sjkim 0xa0000, PAGE_SIZE, 0ul); 340189903Sjkim if (wakeaddr == NULL) { 341189903Sjkim printf("%s: can't alloc wake memory\n", __func__); 342197863Sjkim return (NULL); 343189903Sjkim } 344232082Sjkim if (EVENTHANDLER_REGISTER(power_resume, acpi_stop_beep, NULL, 345232082Sjkim EVENTHANDLER_PRI_LAST) == NULL) { 346232082Sjkim printf("%s: can't register event handler\n", __func__); 347232082Sjkim contigfree(wakeaddr, 4 * PAGE_SIZE, M_DEVBUF); 348232082Sjkim return (NULL); 349232082Sjkim } 350210777Sjkim susppcbs = malloc(mp_ncpus * sizeof(*susppcbs), M_DEVBUF, M_WAITOK); 351231979Skib suspfpusave = malloc(mp_ncpus * sizeof(void *), M_DEVBUF, M_WAITOK); 352231979Skib for (i = 0; i < mp_ncpus; i++) { 353210777Sjkim susppcbs[i] = malloc(sizeof(**susppcbs), M_DEVBUF, M_WAITOK); 354231979Skib suspfpusave[i] = alloc_fpusave(M_WAITOK); 355231979Skib } 356197863Sjkim 357197863Sjkim return (wakeaddr); 358189903Sjkim} 359189903Sjkim 36080028Stakawatavoid 36180028Stakawataacpi_install_wakeup_handler(struct acpi_softc *sc) 36280028Stakawata{ 363197863Sjkim static void *wakeaddr = NULL; 364189903Sjkim uint64_t *pt4, *pt3, *pt2; 365189903Sjkim int i; 366189903Sjkim 367197863Sjkim if (wakeaddr != NULL) 368189903Sjkim return; 369189903Sjkim 370197863Sjkim wakeaddr = acpi_alloc_wakeup_handler(); 371197863Sjkim if (wakeaddr == NULL) 372197863Sjkim return; 373189903Sjkim 374197863Sjkim sc->acpi_wakeaddr = (vm_offset_t)wakeaddr; 375197863Sjkim sc->acpi_wakephys = vtophys(wakeaddr); 376197863Sjkim 377189903Sjkim bcopy(wakecode, (void *)WAKECODE_VADDR(sc), sizeof(wakecode)); 378189903Sjkim 379189903Sjkim /* Patch GDT base address, ljmp targets and page table base address. */ 380189903Sjkim WAKECODE_FIXUP((bootgdtdesc + 2), uint32_t, 381189903Sjkim WAKECODE_PADDR(sc) + bootgdt); 382189903Sjkim WAKECODE_FIXUP((wakeup_sw32 + 2), uint32_t, 383189903Sjkim WAKECODE_PADDR(sc) + wakeup_32); 384189903Sjkim WAKECODE_FIXUP((wakeup_sw64 + 1), uint32_t, 385189903Sjkim WAKECODE_PADDR(sc) + wakeup_64); 386189903Sjkim WAKECODE_FIXUP(wakeup_pagetables, uint32_t, sc->acpi_wakephys); 387189903Sjkim 388189903Sjkim /* Save pointers to some global data. */ 389189903Sjkim WAKECODE_FIXUP(wakeup_retaddr, void *, acpi_restorecpu); 390189903Sjkim WAKECODE_FIXUP(wakeup_kpml4, uint64_t, KPML4phys); 391189903Sjkim WAKECODE_FIXUP(wakeup_ctx, vm_offset_t, 392189903Sjkim WAKECODE_VADDR(sc) + wakeup_ctx); 393189903Sjkim WAKECODE_FIXUP(wakeup_efer, uint64_t, rdmsr(MSR_EFER)); 394189903Sjkim WAKECODE_FIXUP(wakeup_star, uint64_t, rdmsr(MSR_STAR)); 395189903Sjkim WAKECODE_FIXUP(wakeup_lstar, uint64_t, rdmsr(MSR_LSTAR)); 396189903Sjkim WAKECODE_FIXUP(wakeup_cstar, uint64_t, rdmsr(MSR_CSTAR)); 397189903Sjkim WAKECODE_FIXUP(wakeup_sfmask, uint64_t, rdmsr(MSR_SF_MASK)); 398232076Sjkim WAKECODE_FIXUP(wakeup_xsmask, uint64_t, xsave_mask); 399189903Sjkim 400189903Sjkim /* Build temporary page tables below realmode code. */ 401197863Sjkim pt4 = wakeaddr; 402189903Sjkim pt3 = pt4 + (PAGE_SIZE) / sizeof(uint64_t); 403189903Sjkim pt2 = pt3 + (PAGE_SIZE) / sizeof(uint64_t); 404189903Sjkim 405189903Sjkim /* Create the initial 1GB replicated page tables */ 406189903Sjkim for (i = 0; i < 512; i++) { 407189903Sjkim /* 408189903Sjkim * Each slot of the level 4 pages points 409189903Sjkim * to the same level 3 page 410189903Sjkim */ 411189903Sjkim pt4[i] = (uint64_t)(sc->acpi_wakephys + PAGE_SIZE); 412189903Sjkim pt4[i] |= PG_V | PG_RW | PG_U; 413189903Sjkim 414189903Sjkim /* 415189903Sjkim * Each slot of the level 3 pages points 416189903Sjkim * to the same level 2 page 417189903Sjkim */ 418189903Sjkim pt3[i] = (uint64_t)(sc->acpi_wakephys + (2 * PAGE_SIZE)); 419189903Sjkim pt3[i] |= PG_V | PG_RW | PG_U; 420189903Sjkim 421189903Sjkim /* The level 2 page slots are mapped with 2MB pages for 1GB. */ 422189903Sjkim pt2[i] = i * (2 * 1024 * 1024); 423189903Sjkim pt2[i] |= PG_V | PG_RW | PG_PS | PG_U; 424189903Sjkim } 425189903Sjkim 426189903Sjkim if (bootverbose) 427189903Sjkim device_printf(sc->acpi_dev, "wakeup code va %p pa %p\n", 428189903Sjkim (void *)sc->acpi_wakeaddr, (void *)sc->acpi_wakephys); 42980028Stakawata} 430