arch/x86_64/kernel/acpi.c

   1 /*
   2  *  acpi.c - Architecture-Specific Low-Level ACPI Support
   3  *
   4  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
   5  *  Copyright (C) 2001 Jun Nakajima <jun.nakajima@intel.com>
   6  *  Copyright (C) 2001 Patrick Mochel <mochel@osdl.org>
   7  *
   8  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  *
  24  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  25  */
  26
  27 #include <linux/config.h>
  28 #include <linux/kernel.h>
  29 #include <linux/init.h>
  30 #include <linux/types.h>
  31 #include <linux/stddef.h>
  32 #include <linux/slab.h>
  33 #include <linux/pci.h>
  34 #include <linux/bootmem.h>
  35 #include <linux/irq.h>
  36 #include <linux/acpi.h>
  37 #include <asm/mpspec.h>
  38 #include <asm/io.h>
  39 #include <asm/apic.h>
  40 #include <asm/apicdef.h>
  41 #include <asm/page.h>
  42 #include <asm/pgtable.h>
  43 #include <asm/pgalloc.h>
  44 #include <asm/io_apic.h>
  45 #include <asm/proto.h>
  46
  47
  48 #define PREFIX                  "ACPI: "
  49
  50 int acpi_lapic;
  51 int acpi_ioapic;
  52 int acpi_strict;
  53
  54 acpi_interrupt_flags acpi_sci_flags __initdata;
  55 int acpi_sci_override_gsi __initdata;
  56 int acpi_skip_timer_override __initdata;
  57 /* --------------------------------------------------------------------------
  58                               Boot-time Configuration
  59    -------------------------------------------------------------------------- */
  60 #ifdef CONFIG_ACPI_PCI
  61 int acpi_noirq __initdata;      /* skip ACPI IRQ initialization */
  62 int acpi_pci_disabled __initdata; /* skip ACPI PCI scan and IRQ initialization */
  63 #endif
  64 int acpi_ht __initdata = 1;     /* enable HT */
  65
  66 enum acpi_irq_model_id          acpi_irq_model;
  67
  68
  69 /*
  70  * Use reserved fixmap pages for physical-to-virtual mappings of ACPI tables.
  71  * Note that the same range is used for each table, so tables that need to
  72  * persist should be memcpy'd.
  73  */
  74
  75 extern unsigned long end_pfn;
  76
  77 char *
  78 __acpi_map_table (
  79         unsigned long   phys_addr,
  80         unsigned long   size)
  81 {
  82 #if 0
  83         unsigned long   base = 0;
  84         unsigned long   mapped_phys = phys_addr;
  85         unsigned long   offset = phys_addr & (PAGE_SIZE - 1);
  86         unsigned long   mapped_size = PAGE_SIZE - offset;
  87         unsigned long   avail_size = mapped_size + (PAGE_SIZE * FIX_ACPI_PAGES);
  88         int             idx = FIX_ACPI_BEGIN;
  89 #endif
  90
  91         //printk("__acpi_map_table at %lx size %lu\n", phys_addr, size);
  92
  93         if (!phys_addr || !size)
  94                 return NULL;
  95
  96         if (phys_addr < (end_pfn_map << PAGE_SHIFT))
  97                 return __va(phys_addr);
  98
  99         panic("acpi mapping beyond end_pfn: %lx > %lx\n", phys_addr, end_pfn_map<<PAGE_SHIFT);
 100
 101
 102 #if 0
 103         base = fix_to_virt(FIX_ACPI_BEGIN);
 104
 105         set_fixmap(idx, mapped_phys);
 106
 107         if (size > avail_size)
 108                 return NULL;
 109
 110         /* If the table doesn't map completely into the fist page... */
 111         if (size > mapped_size) {
 112                 do {
 113                         /* Make sure we don't go past our range */
 114                         if (idx++ == FIX_ACPI_END)
 115                                 return NULL;
 116                         mapped_phys = mapped_phys + PAGE_SIZE;
 117                         set_fixmap(idx, mapped_phys);
 118                         mapped_size = mapped_size + PAGE_SIZE;
 119                 } while (mapped_size < size);
 120         }
 121
 122         return ((unsigned char *) base + offset);
 123 #endif
 124 }
 125
 126 #ifdef CONFIG_ACPI_MMCONFIG
 127
 128 u32 pci_mmcfg_base_addr;
 129
 130 static int __init
 131 acpi_parse_mcfg(unsigned long phys_addr,
 132                 unsigned long size)
 133 {
 134         struct acpi_table_mcfg *mcfg = NULL;
 135
 136         if (!phys_addr || !size)
 137                 return -EINVAL;
 138
 139         mcfg = (struct acpi_table_mcfg *) __acpi_map_table(phys_addr, size);
 140         if (!mcfg) {
 141                 printk(KERN_WARNING PREFIX "Unable to map MCFG\n");
 142                 return -ENODEV;
 143         }
 144
 145         if (mcfg->base_reserved) {
 146                 printk(KERN_ERR PREFIX "MMCONFIG not in low 4GB of memory\n");
 147                 return -ENODEV;
 148         }
 149
 150         pci_mmcfg_base_addr = mcfg->base_address;
 151
 152         return 0;
 153 }
 154 #endif /* CONFIG_ACPI_MMCONFIG */
 155
 156 #ifdef CONFIG_X86_LOCAL_APIC
 157
 158 static u64 acpi_lapic_addr __initdata = APIC_DEFAULT_PHYS_BASE;
 159
 160 static int __init
 161 acpi_parse_madt (
 162         unsigned long           phys_addr,
 163         unsigned long           size)
 164 {
 165         struct acpi_table_madt  *madt = NULL;
 166
 167         if (!phys_addr || !size)
 168                 return -EINVAL;
 169
 170         madt = (struct acpi_table_madt *) __acpi_map_table(phys_addr, size);
 171         if (!madt) {
 172                 printk(KERN_WARNING PREFIX "Unable to map MADT\n");
 173                 return -ENODEV;
 174         }
 175
 176         if (madt->lapic_address)
 177                 acpi_lapic_addr = (u64) madt->lapic_address;
 178
 179         printk(KERN_INFO PREFIX "Local APIC address 0x%08x\n",
 180                 madt->lapic_address);
 181
 182         return 0;
 183 }
 184
 185
 186 static int __init
 187 acpi_parse_lapic (
 188         acpi_table_entry_header *header)
 189 {
 190         struct acpi_table_lapic *processor = NULL;
 191
 192         processor = (struct acpi_table_lapic*) header;
 193         if (!processor)
 194                 return -EINVAL;
 195
 196         acpi_table_print_madt_entry(header);
 197
 198         mp_register_lapic (
 199                 processor->id,                                     /* APIC ID */
 200                 processor->flags.enabled);                        /* Enabled? */
 201
 202         return 0;
 203 }
 204
 205
 206 static int __init
 207 acpi_parse_lapic_addr_ovr (
 208         acpi_table_entry_header *header)
 209 {
 210         struct acpi_table_lapic_addr_ovr *lapic_addr_ovr = NULL;
 211
 212         lapic_addr_ovr = (struct acpi_table_lapic_addr_ovr*) header;
 213         if (!lapic_addr_ovr)
 214                 return -EINVAL;
 215
 216         acpi_lapic_addr = lapic_addr_ovr->address;
 217
 218         return 0;
 219 }
 220
 221
 222 static int __init
 223 acpi_parse_lapic_nmi (
 224         acpi_table_entry_header *header)
 225 {
 226         struct acpi_table_lapic_nmi *lapic_nmi = NULL;
 227
 228         lapic_nmi = (struct acpi_table_lapic_nmi*) header;
 229         if (!lapic_nmi)
 230                 return -EINVAL;
 231
 232         acpi_table_print_madt_entry(header);
 233
 234         if (lapic_nmi->lint != 1)
 235                 printk(KERN_WARNING PREFIX "NMI not connected to LINT 1!\n");
 236
 237         return 0;
 238 }
 239
 240 #endif /*CONFIG_X86_LOCAL_APIC*/
 241
 242 #if defined(CONFIG_X86_IO_APIC) && defined(CONFIG_ACPI_INTERPRETER)
 243
 244
 245 static int __init
 246 acpi_parse_ioapic (
 247         acpi_table_entry_header *header)
 248 {
 249         struct acpi_table_ioapic *ioapic = NULL;
 250
 251         ioapic = (struct acpi_table_ioapic*) header;
 252         if (!ioapic)
 253                 return -EINVAL;
 254
 255         acpi_table_print_madt_entry(header);
 256
 257         mp_register_ioapic (
 258                 ioapic->id,
 259                 ioapic->address,
 260                 ioapic->global_irq_base);
 261
 262         return 0;
 263 }
 264
 265 /*
 266  * Parse Interrupt Source Override for the ACPI SCI
 267  */
 268 static void
 269 acpi_sci_ioapic_setup(u32 gsi, u16 polarity, u16 trigger)
 270 {
 271         if (trigger == 0)       /* compatible SCI trigger is level */
 272                 trigger = 3;
 273
 274         if (polarity == 0)      /* compatible SCI polarity is low */
 275                 polarity = 3;
 276
 277         /* Command-line over-ride via acpi_sci= */
 278         if (acpi_sci_flags.trigger)
 279                 trigger = acpi_sci_flags.trigger;
 280
 281         if (acpi_sci_flags.polarity)
 282                 polarity = acpi_sci_flags.polarity;
 283
 284         /*
 285          * mp_config_acpi_legacy_irqs() already setup IRQs < 16
 286          * If GSI is < 16, this will update its flags,
 287          * else it will create a new mp_irqs[] entry.
 288          */
 289         mp_override_legacy_irq(gsi, polarity, trigger, gsi);
 290
 291         /*
 292          * stash over-ride to indicate we've been here
 293          * and for later update of acpi_fadt
 294          */
 295         acpi_sci_override_gsi = gsi;
 296         return;
 297 }
 298
 299 static int __init
 300 acpi_parse_fadt(unsigned long phys, unsigned long size)
 301 {
 302         struct fadt_descriptor_rev2 *fadt =0;
 303
 304         fadt = (struct fadt_descriptor_rev2*) __acpi_map_table(phys,size);
 305         if (!fadt) {
 306                 printk(KERN_WARNING PREFIX "Unable to map FADT\n");
 307                 return 0;
 308         }
 309
 310 #ifdef  CONFIG_ACPI_INTERPRETER
 311         /* initialize sci_int early for INT_SRC_OVR MADT parsing */
 312         acpi_fadt.sci_int = fadt->sci_int;
 313 #endif
 314
 315         return 0;
 316 }
 317
 318
 319 static int __init
 320 acpi_parse_int_src_ovr (
 321         acpi_table_entry_header *header)
 322 {
 323         struct acpi_table_int_src_ovr *intsrc = NULL;
 324
 325         intsrc = (struct acpi_table_int_src_ovr*) header;
 326         if (!intsrc)
 327                 return -EINVAL;
 328
 329         acpi_table_print_madt_entry(header);
 330
 331         if (intsrc->bus_irq == acpi_fadt.sci_int) {
 332                 acpi_sci_ioapic_setup(intsrc->global_irq,
 333                         intsrc->flags.polarity, intsrc->flags.trigger);
 334                 return 0;
 335         }
 336
 337         if (acpi_skip_timer_override &&
 338                 intsrc->bus_irq == 0 && intsrc->global_irq == 2) {
 339                 printk(PREFIX "BIOS IRQ0 pin2 override ignored.\n");
 340                 return 0;
 341         }
 342
 343         mp_override_legacy_irq (
 344                 intsrc->bus_irq,
 345                 intsrc->flags.polarity,
 346                 intsrc->flags.trigger,
 347                 intsrc->global_irq);
 348
 349         return 0;
 350 }
 351
 352
 353 static int __init
 354 acpi_parse_nmi_src (
 355         acpi_table_entry_header *header)
 356 {
 357         struct acpi_table_nmi_src *nmi_src = NULL;
 358
 359         nmi_src = (struct acpi_table_nmi_src*) header;
 360         if (!nmi_src)
 361                 return -EINVAL;
 362
 363         acpi_table_print_madt_entry(header);
 364
 365         /* TBD: Support nimsrc entries? */
 366
 367         return 0;
 368 }
 369
 370 #endif /*CONFIG_X86_IO_APIC && CONFIG_ACPI_INTERPRETER*/
 371
 372 #ifdef CONFIG_HPET_TIMER
 373 static int __init
 374 acpi_parse_hpet (
 375         unsigned long           phys_addr,
 376         unsigned long           size)
 377 {
 378         struct acpi_table_hpet *hpet_tbl;
 379
 380         hpet_tbl = __va(phys_addr);
 381
 382         if (hpet_tbl->addr.space_id != ACPI_SPACE_MEM) {
 383                 printk(KERN_WARNING "acpi: HPET timers must be located in memory.\n");
 384                 return -1;
 385         }
 386
 387         hpet_address = hpet_tbl->addr.addrl | ((long) hpet_tbl->addr.addrh << 32);
 388
 389         printk(KERN_INFO "acpi: HPET id: %#x base: %#lx\n", hpet_tbl->id, hpet_address);
 390
 391         return 0;
 392 }
 393 #endif  /* CONFIG_HPET_TIMER */
 394
 395 #ifdef CONFIG_ACPI_BUS
 396 /*
 397  * acpi_pic_sci_set_trigger()
 398  *
 399  * use ELCR to set PIC-mode trigger type for SCI
 400  *
 401  * If a PIC-mode SCI is not recognized or gives spurious IRQ7's
 402  * it may require Edge Trigger -- use "acpi_sci=edge"
 403  *
 404  * Port 0x4d0-4d1 are ECLR1 and ECLR2, the Edge/Level Control Registers
 405  * for the 8259 PIC.  bit[n] = 1 means irq[n] is Level, otherwise Edge.
 406  * ECLR1 is IRQ's 0-7 (IRQ 0, 1, 2 must be 0)
 407  * ECLR2 is IRQ's 8-15 (IRQ 8, 13 must be 0)
 408  */
 409
 410 void __init
 411 acpi_pic_sci_set_trigger(unsigned int irq, u16 trigger)
 412 {
 413         unsigned char mask = 1 << (irq & 7);
 414         unsigned int port = 0x4d0 + (irq >> 3);
 415         unsigned char val = inb(port);
 416
 417
 418         printk(PREFIX "IRQ%d SCI:", irq);
 419         if (!(val & mask)) {
 420                 printk(" Edge");
 421
 422                 if (trigger == 3) {
 423                         printk(" set to Level");
 424                         outb(val | mask, port);
 425                 }
 426         } else {
 427                 printk(" Level");
 428
 429                 if (trigger == 1) {
 430                         printk(" set to Edge");
 431                         outb(val & ~mask, port);
 432                 }
 433         }
 434         printk(" Trigger.\n");
 435 }
 436 #endif /* CONFIG_ACPI_BUS */
 437
 438 static unsigned long __init
 439 acpi_scan_rsdp (
 440         unsigned long           start,
 441         unsigned long           length)
 442 {
 443         unsigned long           offset = 0;
 444         unsigned long           sig_len = sizeof("RSD PTR ") - 1;
 445
 446         /*
 447          * Scan all 16-byte boundaries of the physical memory region for the
 448          * RSDP signature.
 449          */
 450         for (offset = 0; offset < length; offset += 16) {
 451                 if (strncmp((char *) (start + offset), "RSD PTR ", sig_len))
 452                         continue;
 453                 return (start + offset);
 454         }
 455
 456         return 0;
 457 }
 458
 459
 460 unsigned long __init
 461 acpi_find_rsdp (void)
 462 {
 463         unsigned long           rsdp_phys = 0;
 464
 465         /*
 466          * Scan memory looking for the RSDP signature. First search EBDA (low
 467          * memory) paragraphs and then search upper memory (E0000-FFFFF).
 468          */
 469         rsdp_phys = acpi_scan_rsdp (0, 0x400);
 470         if (!rsdp_phys)
 471                 rsdp_phys = acpi_scan_rsdp (0xE0000, 0xFFFFF);
 472
 473         return rsdp_phys;
 474 }
 475
 476
 477 int __init
 478 acpi_boot_init (void)
 479 {
 480         int                     result = 0;
 481
 482         if (acpi_disabled)
 483                 return(1);
 484
 485         /*
 486          * The default interrupt routing model is PIC (8259).  This gets
 487          * overriden if IOAPICs are enumerated (below).
 488          */
 489         acpi_irq_model = ACPI_IRQ_MODEL_PIC;
 490
 491         /*
 492          * Initialize the ACPI boot-time table parser.
 493          */
 494         result = acpi_table_init();
 495         if (result) {
 496                 disable_acpi();
 497                 return result;
 498         }
 499
 500 #ifdef CONFIG_ACPI_MMCONFIG
 501         result = acpi_table_parse(ACPI_MCFG, acpi_parse_mcfg);
 502         if (result < 0) {
 503                 printk(KERN_ERR PREFIX "Error %d parsing MCFG\n", result);
 504         } else if (result > 1) {
 505                 printk(KERN_WARNING PREFIX "Multiple MCFG tables exist\n");
 506         }
 507 #endif
 508
 509 #ifdef CONFIG_X86_LOCAL_APIC
 510
 511         /*
 512          * MADT
 513          * ----
 514          * Parse the Multiple APIC Description Table (MADT), if exists.
 515          * Note that this table provides platform SMP configuration
 516          * information -- the successor to MPS tables.
 517          */
 518
 519         result = acpi_table_parse(ACPI_APIC, acpi_parse_madt);
 520         if (!result) {
 521                 printk(KERN_WARNING PREFIX "MADT not present\n");
 522                 return 0;
 523         }
 524         else if (result < 0) {
 525                 printk(KERN_ERR PREFIX "Error parsing MADT\n");
 526                 return result;
 527         }
 528         else if (result > 1)
 529                 printk(KERN_WARNING PREFIX "Multiple MADT tables exist\n");
 530
 531         /*
 532          * Local APIC
 533          * ----------
 534          * Note that the LAPIC address is obtained from the MADT (32-bit value)
 535          * and (optionally) overriden by a LAPIC_ADDR_OVR entry (64-bit value).
 536          */
 537
 538         result = acpi_table_parse_madt(ACPI_MADT_LAPIC_ADDR_OVR, acpi_parse_lapic_addr_ovr);
 539         if (result < 0) {
 540                 printk(KERN_ERR PREFIX "Error parsing LAPIC address override entry\n");
 541                 return result;
 542         }
 543
 544         mp_register_lapic_address(acpi_lapic_addr);
 545
 546         result = acpi_table_parse_madt(ACPI_MADT_LAPIC, acpi_parse_lapic);
 547         if (!result) {
 548                 printk(KERN_ERR PREFIX "No LAPIC entries present\n");
 549                 /* TBD: Cleanup to allow fallback to MPS */
 550                 return -ENODEV;
 551         }
 552         else if (result < 0) {
 553                 printk(KERN_ERR PREFIX "Error parsing LAPIC entry\n");
 554                 /* TBD: Cleanup to allow fallback to MPS */
 555                 return result;
 556         }
 557
 558         result = acpi_table_parse_madt(ACPI_MADT_LAPIC_NMI, acpi_parse_lapic_nmi);
 559         if (result < 0) {
 560                 printk(KERN_ERR PREFIX "Error parsing LAPIC NMI entry\n");
 561                 /* TBD: Cleanup to allow fallback to MPS */
 562                 return result;
 563         }
 564
 565         acpi_lapic = 1;
 566
 567 #endif /*CONFIG_X86_LOCAL_APIC*/
 568
 569 #if defined(CONFIG_X86_IO_APIC) && defined(CONFIG_ACPI_INTERPRETER)
 570
 571
 572         /*
 573          * if "noapic" boot option, don't look for IO-APICs
 574          */
 575         if (ioapic_setup_disabled()) {
 576                 printk(KERN_INFO PREFIX "Skipping IOAPIC probe "
 577                         "due to 'noapic' option.\n");
 578                 return 1;
 579         }
 580
 581         /*
 582          * I/O APIC
 583          * --------
 584          */
 585
 586         /*
 587          * ACPI interpreter is required to complete interrupt setup,
 588          * so if it is off, don't enumerate the io-apics with ACPI.
 589          * If MPS is present, it will handle them,
 590          * otherwise the system will stay in PIC mode
 591          */
 592         if (acpi_disabled || acpi_noirq) {
 593                 return 1;
 594         }
 595
 596         /*
 597          * if "noapic" boot option, don't look for IO-APICs
 598          */
 599         if (ioapic_setup_disabled()) {
 600                 printk(KERN_INFO PREFIX "Skipping IOAPIC probe "
 601                         "due to 'noapic' option.\n");
 602                 return 1;
 603         }
 604
 605         result = acpi_table_parse_madt(ACPI_MADT_IOAPIC, acpi_parse_ioapic);
 606         if (!result) {
 607                 printk(KERN_ERR PREFIX "No IOAPIC entries present\n");
 608                 return -ENODEV;
 609         }
 610         else if (result < 0) {
 611                 printk(KERN_ERR PREFIX "Error parsing IOAPIC entry\n");
 612                 return result;
 613         }
 614
 615         /* Record sci_int for use when looking for MADT sci_int override */
 616         acpi_table_parse(ACPI_FADT, acpi_parse_fadt);
 617
 618         result = acpi_table_parse_madt(ACPI_MADT_INT_SRC_OVR, acpi_parse_int_src_ovr);
 619         if (result < 0) {
 620                 printk(KERN_ERR PREFIX "Error parsing interrupt source overrides entry\n");
 621                 /* TBD: Cleanup to allow fallback to MPS */
 622                 return result;
 623         }
 624
 625         /*
 626          * If BIOS did not supply an INT_SRC_OVR for the SCI
 627          * pretend we got one so we can set the SCI flags.
 628          */
 629         if (!acpi_sci_override_gsi)
 630                 acpi_sci_ioapic_setup(acpi_fadt.sci_int, 0, 0);
 631
 632         /* Fill in identity legacy mapings where no override */
 633         mp_config_acpi_legacy_irqs();
 634
 635         result = acpi_table_parse_madt(ACPI_MADT_NMI_SRC, acpi_parse_nmi_src);
 636         if (result < 0) {
 637                 printk(KERN_ERR PREFIX "Error parsing NMI SRC entry\n");
 638                 /* TBD: Cleanup to allow fallback to MPS */
 639                 return result;
 640         }
 641
 642         acpi_irq_model = ACPI_IRQ_MODEL_IOAPIC;
 643
 644         acpi_irq_balance_set(NULL);
 645
 646         acpi_ioapic = 1;
 647
 648         if (acpi_lapic && acpi_ioapic)
 649                 smp_found_config = 1;
 650
 651 #ifdef CONFIG_HPET_TIMER
 652         result = acpi_table_parse(ACPI_HPET, acpi_parse_hpet);
 653         if (result < 0)
 654                 printk("ACPI: no HPET table found (%d).\n", result);
 655 #endif
 656
 657 #endif /*CONFIG_X86_IO_APIC && CONFIG_ACPI_INTERPRETER*/
 658
 659         return 0;
 660 }
 661
 662
 663 /* --------------------------------------------------------------------------
 664                               Low-Level Sleep Support
 665    -------------------------------------------------------------------------- */
 666
 667 #ifdef CONFIG_ACPI_SLEEP
 668
 669 /* address in low memory of the wakeup routine. */
 670 unsigned long acpi_wakeup_address = 0;
 671 extern char wakeup_start, wakeup_end;
 672
 673 extern unsigned long FASTCALL(acpi_copy_wakeup_routine(unsigned long));
 674
 675 static void init_low_mapping(void)
 676 {
 677         cpu_pda[0].level4_pgt[0] = cpu_pda[0].level4_pgt[pml4_index(PAGE_OFFSET)];
 678         flush_tlb_all();
 679 }
 680
 681 /**
 682  * acpi_save_state_mem - save kernel state
 683  *
 684  * Create an identity mapped page table and copy the wakeup routine to
 685  * low memory.
 686  */
 687 int acpi_save_state_mem (void)
 688 {
 689         init_low_mapping();
 690
 691         memcpy((void *) acpi_wakeup_address, &wakeup_start, &wakeup_end - &wakeup_start);
 692         acpi_copy_wakeup_routine(acpi_wakeup_address);
 693
 694         return 0;
 695 }
 696
 697 /**
 698  * acpi_save_state_disk - save kernel state to disk
 699  *
 700  */
 701 int acpi_save_state_disk (void)
 702 {
 703         return 1;
 704 }
 705
 706 /*
 707  * acpi_restore_state
 708  */
 709 void acpi_restore_state_mem (void)
 710 {
 711         cpu_pda[0].level4_pgt[0] = 0;
 712         flush_tlb_all();
 713 }
 714
 715 /**
 716  * acpi_reserve_bootmem - do _very_ early ACPI initialisation
 717  *
 718  * We allocate a page in low memory for the wakeup
 719  * routine for when we come back from a sleep state. The
 720  * runtime allocator allows specification of <16M pages, but not
 721  * <1M pages.
 722  */
 723 void __init acpi_reserve_bootmem(void)
 724 {
 725         acpi_wakeup_address = (unsigned long)alloc_bootmem_low(PAGE_SIZE);
 726         if ((&wakeup_end - &wakeup_start) > PAGE_SIZE)
 727                 printk(KERN_CRIT "ACPI: Wakeup code way too big, will crash on attempt to suspend\n");
 728         printk(KERN_DEBUG "ACPI: have wakeup address 0x%8.8lx\n", acpi_wakeup_address);
 729 }
 730
 731 #endif /*CONFIG_ACPI_SLEEP*/
 732
 733