Merge git://git.kernel.org/pub/scm/linux/kernel/git/x86/linux-2.6-x86

* git://git.kernel.org/pub/scm/linux/kernel/git/x86/linux-2.6-x86: (32 commits)
  x86: cpa, strict range check in try_preserve_large_page()
  x86: cpa, enable CONFIG_DEBUG_PAGEALLOC on 64-bit
  x86: cpa, use page pool
  x86: introduce page pool in cpa
  x86: DEBUG_PAGEALLOC: enable after mem_init()
  brk: help text typo fix
  lguest: accept guest _PAGE_PWT page table entries
  x86 PM: update stale comments
  x86 PM: consolidate suspend and hibernation code
  x86 PM: rename 32-bit files in arch/x86/power
  x86 PM: move 64-bit hibernation files to arch/x86/power
  x86: trivial printk optimizations
  x86: fix early_ioremap pagetable ops
  x86: construct 32-bit boot time page tables in native format.
  x86, core: remove CONFIG_FORCED_INLINING
  x86: avoid unused variable warning in mm/init_64.c
  x86: fixup more paravirt fallout
  brk: document randomize_va_space and CONFIG_COMPAT_BRK (was Re:
  x86: fix sparse warnings in acpi/bus.c
  x86: fix sparse warning in topology.c
  ...

11 files changed, 207 insertions, 576 deletions

diff --git a/arch/x86/kernel/Makefile b/arch/x86/kernel/Makefile
index 21dc1a061bf1..76ec0f8f138a 100644
--- a/arch/x86/kernel/Makefile
+++ b/arch/x86/kernel/Makefile
@@ -84,8 +84,6 @@ ifeq ($(CONFIG_X86_64),y)
         obj-y                           += genapic_64.o genapic_flat_64.o
         obj-$(CONFIG_X86_PM_TIMER)      += pmtimer_64.o
         obj-$(CONFIG_AUDIT)             += audit_64.o
-        obj-$(CONFIG_PM)                += suspend_64.o
-        obj-$(CONFIG_HIBERNATION)       += suspend_asm_64.o
 
         obj-$(CONFIG_GART_IOMMU)        += pci-gart_64.o aperture_64.o
         obj-$(CONFIG_CALGARY_IOMMU)     += pci-calgary_64.o tce_64.o
diff --git a/arch/x86/kernel/cpu/mcheck/therm_throt.c b/arch/x86/kernel/cpu/mcheck/therm_throt.c
index 24885be5c48c..9b7e01daa1ca 100644
--- a/arch/x86/kernel/cpu/mcheck/therm_throt.c
+++ b/arch/x86/kernel/cpu/mcheck/therm_throt.c
@@ -118,7 +118,7 @@ static __cpuinit int thermal_throttle_add_dev(struct sys_device *sys_dev)
 
 static __cpuinit void thermal_throttle_remove_dev(struct sys_device *sys_dev)
 {
-        return sysfs_remove_group(&sys_dev->kobj, &thermal_throttle_attr_group);
+        sysfs_remove_group(&sys_dev->kobj, &thermal_throttle_attr_group);
 }
 
 /* Mutex protecting device creation against CPU hotplug */
diff --git a/arch/x86/kernel/entry_32.S b/arch/x86/kernel/entry_32.S
index be5c31d04884..824e21b80aad 100644
--- a/arch/x86/kernel/entry_32.S
+++ b/arch/x86/kernel/entry_32.S
@@ -409,7 +409,8 @@ restore_nocheck_notrace:
         RESTORE_REGS
         addl $4, %esp                   # skip orig_eax/error_code
         CFI_ADJUST_CFA_OFFSET -4
-1:      INTERRUPT_RETURN
+ENTRY(irq_return)
+        INTERRUPT_RETURN
 .section .fixup,"ax"
 iret_exc:
         pushl $0                        # no error code
@@ -418,7 +419,7 @@ iret_exc:
 .previous
 .section __ex_table,"a"
         .align 4
-        .long 1b,iret_exc
+        .long irq_return,iret_exc
 .previous
 
         CFI_RESTORE_STATE
@@ -865,20 +866,16 @@ nmi_espfix_stack:
         RESTORE_REGS
         lss 12+4(%esp), %esp            # back to espfix stack
         CFI_ADJUST_CFA_OFFSET -24
-1:      INTERRUPT_RETURN
+        jmp irq_return
         CFI_ENDPROC
-.section __ex_table,"a"
-        .align 4
-        .long 1b,iret_exc
-.previous
 KPROBE_END(nmi)
 
 #ifdef CONFIG_PARAVIRT
 ENTRY(native_iret)
-1:      iret
+        iret
 .section __ex_table,"a"
         .align 4
-        .long 1b,iret_exc
+        .long native_iret, iret_exc
 .previous
 END(native_iret)
 
diff --git a/arch/x86/kernel/entry_64.S b/arch/x86/kernel/entry_64.S
index c7341e81941c..6be39a387c5a 100644
--- a/arch/x86/kernel/entry_64.S
+++ b/arch/x86/kernel/entry_64.S
@@ -581,16 +581,24 @@ retint_restore_args:	/* return to kernel space */
          */
         TRACE_IRQS_IRETQ
 restore_args:
-        RESTORE_ARGS 0,8,0                                              
-#ifdef CONFIG_PARAVIRT
+        RESTORE_ARGS 0,8,0
+
+ENTRY(irq_return)
         INTERRUPT_RETURN
-#endif
+
+        .section __ex_table, "a"
+        .quad irq_return, bad_iret
+        .previous
+
+#ifdef CONFIG_PARAVIRT
 ENTRY(native_iret)
         iretq
 
         .section __ex_table,"a"
         .quad native_iret, bad_iret
         .previous
+#endif
+
         .section .fixup,"ax"
 bad_iret:
         /*
@@ -804,7 +812,7 @@ paranoid_swapgs\trace:
         SWAPGS_UNSAFE_STACK
 paranoid_restore\trace:
         RESTORE_ALL 8
-        INTERRUPT_RETURN
+        jmp irq_return
 paranoid_userspace\trace:
         GET_THREAD_INFO(%rcx)
         movl threadinfo_flags(%rcx),%ebx
@@ -919,7 +927,7 @@ error_kernelspace:
            iret run with kernel gs again, so don't set the user space flag.
            B stepping K8s sometimes report an truncated RIP for IRET 
            exceptions returning to compat mode. Check for these here too. */
-        leaq native_iret(%rip),%rbp
+        leaq irq_return(%rip),%rbp
         cmpq %rbp,RIP(%rsp) 
         je   error_swapgs
         movl %ebp,%ebp  /* zero extend */
diff --git a/arch/x86/kernel/geode_32.c b/arch/x86/kernel/geode_32.c
index 9c7f7d395968..9dad6ca6cd70 100644
--- a/arch/x86/kernel/geode_32.c
+++ b/arch/x86/kernel/geode_32.c
@@ -163,14 +163,11 @@ EXPORT_SYMBOL_GPL(geode_gpio_setup_event);
 
 static int __init geode_southbridge_init(void)
 {
-        int timers;
-
         if (!is_geode())
                 return -ENODEV;
 
         init_lbars();
-        timers = geode_mfgpt_detect();
-        printk(KERN_INFO "geode:  %d MFGPT timers available.\n", timers);
+        (void) mfgpt_timer_setup();
         return 0;
 }
 
diff --git a/arch/x86/kernel/head_32.S b/arch/x86/kernel/head_32.S
index 5d8c5730686b..74ef4a41f224 100644
--- a/arch/x86/kernel/head_32.S
+++ b/arch/x86/kernel/head_32.S
@@ -19,6 +19,10 @@
 #include <asm/thread_info.h>
 #include <asm/asm-offsets.h>
 #include <asm/setup.h>
+#include <asm/processor-flags.h>
+
+/* Physical address */
+#define pa(X) ((X) - __PAGE_OFFSET)
 
 /*
  * References to members of the new_cpu_data structure.
@@ -80,10 +84,6 @@ INIT_MAP_BEYOND_END = BOOTBITMAP_SIZE + (PAGE_TABLE_SIZE + ALLOCATOR_SLOP)*PAGE_
  */
 .section .text.head,"ax",@progbits
 ENTRY(startup_32)
-        /* check to see if KEEP_SEGMENTS flag is meaningful */
-        cmpw $0x207, BP_version(%esi)
-        jb 1f
-
         /* test KEEP_SEGMENTS flag to see if the bootloader is asking
                 us to not reload segments */
         testb $(1<<6), BP_loadflags(%esi)
@@ -92,7 +92,7 @@ ENTRY(startup_32)
 /*
  * Set segments to known values.
  */
-1:      lgdt boot_gdt_descr - __PAGE_OFFSET
+        lgdt pa(boot_gdt_descr)
         movl $(__BOOT_DS),%eax
         movl %eax,%ds
         movl %eax,%es
@@ -105,8 +105,8 @@ ENTRY(startup_32)
  */
         cld
         xorl %eax,%eax
-        movl $__bss_start - __PAGE_OFFSET,%edi
-        movl $__bss_stop - __PAGE_OFFSET,%ecx
+        movl $pa(__bss_start),%edi
+        movl $pa(__bss_stop),%ecx
         subl %edi,%ecx
         shrl $2,%ecx
         rep ; stosl
@@ -118,31 +118,32 @@ ENTRY(startup_32)
  * (kexec on panic case). Hence copy out the parameters before initializing
  * page tables.
  */
-        movl $(boot_params - __PAGE_OFFSET),%edi
+        movl $pa(boot_params),%edi
         movl $(PARAM_SIZE/4),%ecx
         cld
         rep
         movsl
-        movl boot_params - __PAGE_OFFSET + NEW_CL_POINTER,%esi
+        movl pa(boot_params) + NEW_CL_POINTER,%esi
         andl %esi,%esi
         jz 1f                   # No comand line
-        movl $(boot_command_line - __PAGE_OFFSET),%edi
+        movl $pa(boot_command_line),%edi
         movl $(COMMAND_LINE_SIZE/4),%ecx
         rep
         movsl
 1:
 
 #ifdef CONFIG_PARAVIRT
-        cmpw $0x207, (boot_params + BP_version - __PAGE_OFFSET)
+        /* This is can only trip for a broken bootloader... */
+        cmpw $0x207, pa(boot_params + BP_version)
         jb default_entry
 
         /* Paravirt-compatible boot parameters.  Look to see what architecture
                 we're booting under. */
-        movl (boot_params + BP_hardware_subarch - __PAGE_OFFSET), %eax
+        movl pa(boot_params + BP_hardware_subarch), %eax
         cmpl $num_subarch_entries, %eax
         jae bad_subarch
 
-        movl subarch_entries - __PAGE_OFFSET(,%eax,4), %eax
+        movl pa(subarch_entries)(,%eax,4), %eax
         subl $__PAGE_OFFSET, %eax
         jmp *%eax
 
@@ -170,17 +171,68 @@ num_subarch_entries = (. - subarch_entries) / 4
  * Mappings are created both at virtual address 0 (identity mapping)
  * and PAGE_OFFSET for up to _end+sizeof(page tables)+INIT_MAP_BEYOND_END.
  *
- * Warning: don't use %esi or the stack in this code.  However, %esp
- * can be used as a GPR if you really need it...
+ * Note that the stack is not yet set up!
  */
-page_pde_offset = (__PAGE_OFFSET >> 20);
+#define PTE_ATTR        0x007           /* PRESENT+RW+USER */
+#define PDE_ATTR        0x067           /* PRESENT+RW+USER+DIRTY+ACCESSED */
+#define PGD_ATTR        0x001           /* PRESENT (no other attributes) */
 
 default_entry:
-        movl $(pg0 - __PAGE_OFFSET), %edi
-        movl $(swapper_pg_dir - __PAGE_OFFSET), %edx
-        movl $0x007, %eax                       /* 0x007 = PRESENT+RW+USER */
+#ifdef CONFIG_X86_PAE
+
+        /*
+         * In PAE mode swapper_pg_dir is statically defined to contain enough
+         * entries to cover the VMSPLIT option (that is the top 1, 2 or 3
+         * entries). The identity mapping is handled by pointing two PGD
+         * entries to the first kernel PMD.
+         *
+         * Note the upper half of each PMD or PTE are always zero at
+         * this stage.
+         */
+
+#define KPMDS ((0x100000000-__PAGE_OFFSET) >> 30) /* Number of kernel PMDs */
+
+        xorl %ebx,%ebx                          /* %ebx is kept at zero */
+
+        movl $pa(pg0), %edi
+        movl $pa(swapper_pg_pmd), %edx
+        movl $PTE_ATTR, %eax
+10:
+        leal PDE_ATTR(%edi),%ecx                /* Create PMD entry */
+        movl %ecx,(%edx)                        /* Store PMD entry */
+                                                /* Upper half already zero */
+        addl $8,%edx
+        movl $512,%ecx
+11:
+        stosl
+        xchgl %eax,%ebx
+        stosl
+        xchgl %eax,%ebx
+        addl $0x1000,%eax
+        loop 11b
+
+        /*
+         * End condition: we must map up to and including INIT_MAP_BEYOND_END
+         * bytes beyond the end of our own page tables.
+         */
+        leal (INIT_MAP_BEYOND_END+PTE_ATTR)(%edi),%ebp
+        cmpl %ebp,%eax
+        jb 10b
+1:
+        movl %edi,pa(init_pg_tables_end)
+
+        /* Do early initialization of the fixmap area */
+        movl $pa(swapper_pg_fixmap)+PDE_ATTR,%eax
+        movl %eax,pa(swapper_pg_pmd+0x1000*KPMDS-8)
+#else   /* Not PAE */
+
+page_pde_offset = (__PAGE_OFFSET >> 20);
+
+        movl $pa(pg0), %edi
+        movl $pa(swapper_pg_dir), %edx
+        movl $PTE_ATTR, %eax
 10:
-        leal 0x007(%edi),%ecx                   /* Create PDE entry */
+        leal PDE_ATTR(%edi),%ecx                /* Create PDE entry */
         movl %ecx,(%edx)                        /* Store identity PDE entry */
         movl %ecx,page_pde_offset(%edx)         /* Store kernel PDE entry */
         addl $4,%edx
@@ -189,19 +241,20 @@ default_entry:
         stosl
         addl $0x1000,%eax
         loop 11b
-        /* End condition: we must map up to and including INIT_MAP_BEYOND_END */
-        /* bytes beyond the end of our own page tables; the +0x007 is the attribute bits */
-        leal (INIT_MAP_BEYOND_END+0x007)(%edi),%ebp
+        /*
+         * End condition: we must map up to and including INIT_MAP_BEYOND_END
+         * bytes beyond the end of our own page tables; the +0x007 is
+         * the attribute bits
+         */
+        leal (INIT_MAP_BEYOND_END+PTE_ATTR)(%edi),%ebp
         cmpl %ebp,%eax
         jb 10b
-        movl %edi,(init_pg_tables_end - __PAGE_OFFSET)
-
-        /* Do an early initialization of the fixmap area */
-        movl $(swapper_pg_dir - __PAGE_OFFSET), %edx
-        movl $(swapper_pg_pmd - __PAGE_OFFSET), %eax
-        addl $0x67, %eax                        /* 0x67 == _PAGE_TABLE */
-        movl %eax, 4092(%edx)
+        movl %edi,pa(init_pg_tables_end)
 
+        /* Do early initialization of the fixmap area */
+        movl $pa(swapper_pg_fixmap)+PDE_ATTR,%eax
+        movl %eax,pa(swapper_pg_dir+0xffc)
+#endif
         jmp 3f
 /*
  * Non-boot CPU entry point; entered from trampoline.S
@@ -241,7 +294,7 @@ ENTRY(startup_32_smp)
  *      NOTE! We have to correct for the fact that we're
  *      not yet offset PAGE_OFFSET..
  */
-#define cr4_bits mmu_cr4_features-__PAGE_OFFSET
+#define cr4_bits pa(mmu_cr4_features)
         movl cr4_bits,%edx
         andl %edx,%edx
         jz 6f
@@ -276,10 +329,10 @@ ENTRY(startup_32_smp)
 /*
  * Enable paging
  */
-        movl $swapper_pg_dir-__PAGE_OFFSET,%eax
+        movl $pa(swapper_pg_dir),%eax
         movl %eax,%cr3          /* set the page table pointer.. */
         movl %cr0,%eax
-        orl $0x80000000,%eax
+        orl  $X86_CR0_PG,%eax
         movl %eax,%cr0          /* ..and set paging (PG) bit */
         ljmp $__BOOT_CS,$1f     /* Clear prefetch and normalize %eip */
 1:
@@ -552,16 +605,44 @@ ENTRY(_stext)
  */
 .section ".bss.page_aligned","wa"
         .align PAGE_SIZE_asm
+#ifdef CONFIG_X86_PAE
+ENTRY(swapper_pg_pmd)
+        .fill 1024*KPMDS,4,0
+#else
 ENTRY(swapper_pg_dir)
         .fill 1024,4,0
-ENTRY(swapper_pg_pmd)
+#endif
+ENTRY(swapper_pg_fixmap)
         .fill 1024,4,0
 ENTRY(empty_zero_page)
         .fill 4096,1,0
-
 /*
  * This starts the data section.
  */
+#ifdef CONFIG_X86_PAE
+.section ".data.page_aligned","wa"
+        /* Page-aligned for the benefit of paravirt? */
+        .align PAGE_SIZE_asm
+ENTRY(swapper_pg_dir)
+        .long   pa(swapper_pg_pmd+PGD_ATTR),0           /* low identity map */
+# if KPMDS == 3
+        .long   pa(swapper_pg_pmd+PGD_ATTR),0
+        .long   pa(swapper_pg_pmd+PGD_ATTR+0x1000),0
+        .long   pa(swapper_pg_pmd+PGD_ATTR+0x2000),0
+# elif KPMDS == 2
+        .long   0,0
+        .long   pa(swapper_pg_pmd+PGD_ATTR),0
+        .long   pa(swapper_pg_pmd+PGD_ATTR+0x1000),0
+# elif KPMDS == 1
+        .long   0,0
+        .long   0,0
+        .long   pa(swapper_pg_pmd+PGD_ATTR),0
+# else
+#  error "Kernel PMDs should be 1, 2 or 3"
+# endif
+        .align PAGE_SIZE_asm            /* needs to be page-sized too */
+#endif
+
 .data
 ENTRY(stack_start)
         .long init_thread_union+THREAD_SIZE
diff --git a/arch/x86/kernel/mfgpt_32.c b/arch/x86/kernel/mfgpt_32.c
index 219f86eb6123..027fc067b399 100644
--- a/arch/x86/kernel/mfgpt_32.c
+++ b/arch/x86/kernel/mfgpt_32.c
@@ -12,48 +12,37 @@
  */
 
 /*
- * We are using the 32Khz input clock - its the only one that has the
+ * We are using the 32.768kHz input clock - it's the only one that has the
  * ranges we find desirable.  The following table lists the suitable
- * divisors and the associated hz, minimum interval
- * and the maximum interval:
+ * divisors and the associated Hz, minimum interval and the maximum interval:
  *
- *  Divisor   Hz      Min Delta (S) Max Delta (S)
- *   1        32000     .0005          2.048
- *   2        16000      .001          4.096
- *   4         8000      .002          8.192
- *   8         4000      .004         16.384
- *   16        2000      .008         32.768
- *   32        1000      .016         65.536
- *   64         500      .032        131.072
- *  128         250      .064        262.144
- *  256         125      .128        524.288
+ *  Divisor   Hz      Min Delta (s)  Max Delta (s)
+ *   1        32768   .00048828125      2.000
+ *   2        16384   .0009765625       4.000
+ *   4         8192   .001953125        8.000
+ *   8         4096   .00390625        16.000
+ *   16        2048   .0078125         32.000
+ *   32        1024   .015625          64.000
+ *   64         512   .03125          128.000
+ *  128         256   .0625           256.000
+ *  256         128   .125            512.000
  */
 
 #include <linux/kernel.h>
 #include <linux/interrupt.h>
-#include <linux/module.h>
 #include <asm/geode.h>
 
-#define F_AVAIL    0x01
-
 static struct mfgpt_timer_t {
-        int flags;
-        struct module *owner;
+        unsigned int avail:1;
 } mfgpt_timers[MFGPT_MAX_TIMERS];
 
 /* Selected from the table above */
 
 #define MFGPT_DIVISOR 16
 #define MFGPT_SCALE  4     /* divisor = 2^(scale) */
-#define MFGPT_HZ  (32000 / MFGPT_DIVISOR)
+#define MFGPT_HZ  (32768 / MFGPT_DIVISOR)
 #define MFGPT_PERIODIC (MFGPT_HZ / HZ)
 
-#ifdef CONFIG_GEODE_MFGPT_TIMER
-static int __init mfgpt_timer_setup(void);
-#else
-#define mfgpt_timer_setup() (0)
-#endif
-
 /* Allow for disabling of MFGPTs */
 static int disable;
 static int __init mfgpt_disable(char *s)
@@ -85,28 +74,37 @@ __setup("mfgptfix", mfgpt_fix);
  * In other cases (such as with VSAless OpenFirmware), the system firmware
  * leaves timers available for us to use.
  */
-int __init geode_mfgpt_detect(void)
+
+
+static int timers = -1;
+
+static void geode_mfgpt_detect(void)
 {
-        int count = 0, i;
+        int i;
         u16 val;
 
+        timers = 0;
+
         if (disable) {
-                printk(KERN_INFO "geode-mfgpt:  Skipping MFGPT setup\n");
-                return 0;
+                printk(KERN_INFO "geode-mfgpt:  MFGPT support is disabled\n");
+                goto done;
+        }
+
+        if (!geode_get_dev_base(GEODE_DEV_MFGPT)) {
+                printk(KERN_INFO "geode-mfgpt:  MFGPT LBAR is not set up\n");
+                goto done;
         }
 
         for (i = 0; i < MFGPT_MAX_TIMERS; i++) {
                 val = geode_mfgpt_read(i, MFGPT_REG_SETUP);
                 if (!(val & MFGPT_SETUP_SETUP)) {
-                        mfgpt_timers[i].flags = F_AVAIL;
-                        count++;
+                        mfgpt_timers[i].avail = 1;
+                        timers++;
                 }
         }
 
-        /* set up clock event device, if desired */
-        i = mfgpt_timer_setup();
-
-        return count;
+done:
+        printk(KERN_INFO "geode-mfgpt:  %d MFGPT timers available.\n", timers);
 }
 
 int geode_mfgpt_toggle_event(int timer, int cmp, int event, int enable)
@@ -183,36 +181,41 @@ int geode_mfgpt_set_irq(int timer, int cmp, int irq, int enable)
         return 0;
 }
 
-static int mfgpt_get(int timer, struct module *owner)
+static int mfgpt_get(int timer)
 {
-        mfgpt_timers[timer].flags &= ~F_AVAIL;
-        mfgpt_timers[timer].owner = owner;
+        mfgpt_timers[timer].avail = 0;
         printk(KERN_INFO "geode-mfgpt:  Registered timer %d\n", timer);
         return timer;
 }
 
-int geode_mfgpt_alloc_timer(int timer, int domain, struct module *owner)
+int geode_mfgpt_alloc_timer(int timer, int domain)
 {
         int i;
 
-        if (!geode_get_dev_base(GEODE_DEV_MFGPT))
-                return -ENODEV;
+        if (timers == -1) {
+                /* timers haven't been detected yet */
+                geode_mfgpt_detect();
+        }
+
+        if (!timers)
+                return -1;
+
         if (timer >= MFGPT_MAX_TIMERS)
-                return -EIO;
+                return -1;
 
         if (timer < 0) {
                 /* Try to find an available timer */
                 for (i = 0; i < MFGPT_MAX_TIMERS; i++) {
-                        if (mfgpt_timers[i].flags & F_AVAIL)
-                                return mfgpt_get(i, owner);
+                        if (mfgpt_timers[i].avail)
+                                return mfgpt_get(i);
 
                         if (i == 5 && domain == MFGPT_DOMAIN_WORKING)
                                 break;
                 }
         } else {
                 /* If they requested a specific timer, try to honor that */
-                if (mfgpt_timers[timer].flags & F_AVAIL)
-                        return mfgpt_get(timer, owner);
+                if (mfgpt_timers[timer].avail)
+                        return mfgpt_get(timer);
         }
 
         /* No timers available - too bad */
@@ -244,10 +247,11 @@ static int __init mfgpt_setup(char *str)
 }
 __setup("mfgpt_irq=", mfgpt_setup);
 
-static inline void mfgpt_disable_timer(u16 clock)
+static void mfgpt_disable_timer(u16 clock)
 {
-        u16 val = geode_mfgpt_read(clock, MFGPT_REG_SETUP);
-        geode_mfgpt_write(clock, MFGPT_REG_SETUP, val & ~MFGPT_SETUP_CNTEN);
+        /* avoid races by clearing CMP1 and CMP2 unconditionally */
+        geode_mfgpt_write(clock, MFGPT_REG_SETUP, (u16) ~MFGPT_SETUP_CNTEN |
+                        MFGPT_SETUP_CMP1 | MFGPT_SETUP_CMP2);
 }
 
 static int mfgpt_next_event(unsigned long, struct clock_event_device *);
@@ -263,7 +267,7 @@ static struct clock_event_device mfgpt_clockevent = {
         .shift = 32
 };
 
-static inline void mfgpt_start_timer(u16 clock, u16 delta)
+static void mfgpt_start_timer(u16 delta)
 {
         geode_mfgpt_write(mfgpt_event_clock, MFGPT_REG_CMP2, (u16) delta);
         geode_mfgpt_write(mfgpt_event_clock, MFGPT_REG_COUNTER, 0);
@@ -278,21 +282,25 @@ static void mfgpt_set_mode(enum clock_event_mode mode,
         mfgpt_disable_timer(mfgpt_event_clock);
 
         if (mode == CLOCK_EVT_MODE_PERIODIC)
-                mfgpt_start_timer(mfgpt_event_clock, MFGPT_PERIODIC);
+                mfgpt_start_timer(MFGPT_PERIODIC);
 
         mfgpt_tick_mode = mode;
 }
 
 static int mfgpt_next_event(unsigned long delta, struct clock_event_device *evt)
 {
-        mfgpt_start_timer(mfgpt_event_clock, delta);
+        mfgpt_start_timer(delta);
         return 0;
 }
 
-/* Assume (foolishly?), that this interrupt was due to our tick */
-
 static irqreturn_t mfgpt_tick(int irq, void *dev_id)
 {
+        u16 val = geode_mfgpt_read(mfgpt_event_clock, MFGPT_REG_SETUP);
+
+        /* See if the interrupt was for us */
+        if (!(val & (MFGPT_SETUP_SETUP  | MFGPT_SETUP_CMP2 | MFGPT_SETUP_CMP1)))
+                return IRQ_NONE;
+
         /* Turn off the clock (and clear the event) */
         mfgpt_disable_timer(mfgpt_event_clock);
 
@@ -320,13 +328,12 @@ static struct irqaction mfgptirq  = {
         .name = "mfgpt-timer"
 };
 
-static int __init mfgpt_timer_setup(void)
+int __init mfgpt_timer_setup(void)
 {
         int timer, ret;
         u16 val;
 
-        timer = geode_mfgpt_alloc_timer(MFGPT_TIMER_ANY, MFGPT_DOMAIN_WORKING,
-                        THIS_MODULE);
+        timer = geode_mfgpt_alloc_timer(MFGPT_TIMER_ANY, MFGPT_DOMAIN_WORKING);
         if (timer < 0) {
                 printk(KERN_ERR
                        "mfgpt-timer:  Could not allocate a MFPGT timer\n");
@@ -363,7 +370,7 @@ static int __init mfgpt_timer_setup(void)
                         &mfgpt_clockevent);
 
         printk(KERN_INFO
-               "mfgpt-timer:  registering the MFGT timer as a clock event.\n");
+               "mfgpt-timer:  registering the MFGPT timer as a clock event.\n");
         clockevents_register_device(&mfgpt_clockevent);
 
         return 0;
diff --git a/arch/x86/kernel/setup_32.c b/arch/x86/kernel/setup_32.c
index d1d8c347cc0b..691ab4cb167b 100644
--- a/arch/x86/kernel/setup_32.c
+++ b/arch/x86/kernel/setup_32.c
@@ -154,7 +154,11 @@ struct cpuinfo_x86 new_cpu_data __cpuinitdata = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
 struct cpuinfo_x86 boot_cpu_data __read_mostly = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
 EXPORT_SYMBOL(boot_cpu_data);
 
+#ifndef CONFIG_X86_PAE
 unsigned long mmu_cr4_features;
+#else
+unsigned long mmu_cr4_features = X86_CR4_PAE;
+#endif
 
 /* for MCA, but anyone else can use it if they want */
 unsigned int machine_id;
diff --git a/arch/x86/kernel/suspend_64.c b/arch/x86/kernel/suspend_64.c
deleted file mode 100644
index 7ac7130022f1..000000000000
--- a/arch/x86/kernel/suspend_64.c
+++ /dev/null
@@ -1,320 +0,0 @@
-/*
- * Suspend support specific for i386.
- *
- * Distribute under GPLv2
- *
- * Copyright (c) 2002 Pavel Machek <pavel@suse.cz>
- * Copyright (c) 2001 Patrick Mochel <mochel@osdl.org>
- */
-
-#include <linux/smp.h>
-#include <linux/suspend.h>
-#include <asm/proto.h>
-#include <asm/page.h>
-#include <asm/pgtable.h>
-#include <asm/mtrr.h>
-
-/* References to section boundaries */
-extern const void __nosave_begin, __nosave_end;
-
-static void fix_processor_context(void);
-
-struct saved_context saved_context;
-
-/**
- *      __save_processor_state - save CPU registers before creating a
- *              hibernation image and before restoring the memory state from it
- *      @ctxt - structure to store the registers contents in
- *
- *      NOTE: If there is a CPU register the modification of which by the
- *      boot kernel (ie. the kernel used for loading the hibernation image)
- *      might affect the operations of the restored target kernel (ie. the one
- *      saved in the hibernation image), then its contents must be saved by this
- *      function.  In other words, if kernel A is hibernated and different
- *      kernel B is used for loading the hibernation image into memory, the
- *      kernel A's __save_processor_state() function must save all registers
- *      needed by kernel A, so that it can operate correctly after the resume
- *      regardless of what kernel B does in the meantime.
- */
-static void __save_processor_state(struct saved_context *ctxt)
-{
-        kernel_fpu_begin();
-
-        /*
-         * descriptor tables
-         */
-        store_gdt((struct desc_ptr *)&ctxt->gdt_limit);
-        store_idt((struct desc_ptr *)&ctxt->idt_limit);
-        store_tr(ctxt->tr);
-
-        /* XMM0..XMM15 should be handled by kernel_fpu_begin(). */
-        /*
-         * segment registers
-         */
-        asm volatile ("movw %%ds, %0" : "=m" (ctxt->ds));
-        asm volatile ("movw %%es, %0" : "=m" (ctxt->es));
-        asm volatile ("movw %%fs, %0" : "=m" (ctxt->fs));
-        asm volatile ("movw %%gs, %0" : "=m" (ctxt->gs));
-        asm volatile ("movw %%ss, %0" : "=m" (ctxt->ss));
-
-        rdmsrl(MSR_FS_BASE, ctxt->fs_base);
-        rdmsrl(MSR_GS_BASE, ctxt->gs_base);
-        rdmsrl(MSR_KERNEL_GS_BASE, ctxt->gs_kernel_base);
-        mtrr_save_fixed_ranges(NULL);
-
-        /*
-         * control registers 
-         */
-        rdmsrl(MSR_EFER, ctxt->efer);
-        ctxt->cr0 = read_cr0();
-        ctxt->cr2 = read_cr2();
-        ctxt->cr3 = read_cr3();
-        ctxt->cr4 = read_cr4();
-        ctxt->cr8 = read_cr8();
-}
-
-void save_processor_state(void)
-{
-        __save_processor_state(&saved_context);
-}
-
-static void do_fpu_end(void)
-{
-        /*
-         * Restore FPU regs if necessary
-         */
-        kernel_fpu_end();
-}
-
-/**
- *      __restore_processor_state - restore the contents of CPU registers saved
- *              by __save_processor_state()
- *      @ctxt - structure to load the registers contents from
- */
-static void __restore_processor_state(struct saved_context *ctxt)
-{
-        /*
-         * control registers
-         */
-        wrmsrl(MSR_EFER, ctxt->efer);
-        write_cr8(ctxt->cr8);
-        write_cr4(ctxt->cr4);
-        write_cr3(ctxt->cr3);
-        write_cr2(ctxt->cr2);
-        write_cr0(ctxt->cr0);
-
-        /*
-         * now restore the descriptor tables to their proper values
-         * ltr is done i fix_processor_context().
-         */
-        load_gdt((const struct desc_ptr *)&ctxt->gdt_limit);
-        load_idt((const struct desc_ptr *)&ctxt->idt_limit);
-
-
-        /*
-         * segment registers
-         */
-        asm volatile ("movw %0, %%ds" :: "r" (ctxt->ds));
-        asm volatile ("movw %0, %%es" :: "r" (ctxt->es));
-        asm volatile ("movw %0, %%fs" :: "r" (ctxt->fs));
-        load_gs_index(ctxt->gs);
-        asm volatile ("movw %0, %%ss" :: "r" (ctxt->ss));
-
-        wrmsrl(MSR_FS_BASE, ctxt->fs_base);
-        wrmsrl(MSR_GS_BASE, ctxt->gs_base);
-        wrmsrl(MSR_KERNEL_GS_BASE, ctxt->gs_kernel_base);
-
-        fix_processor_context();
-
-        do_fpu_end();
-        mtrr_ap_init();
-}
-
-void restore_processor_state(void)
-{
-        __restore_processor_state(&saved_context);
-}
-
-static void fix_processor_context(void)
-{
-        int cpu = smp_processor_id();
-        struct tss_struct *t = &per_cpu(init_tss, cpu);
-
-        /*
-         * This just modifies memory; should not be necessary. But... This
-         * is necessary, because 386 hardware has concept of busy TSS or some
-         * similar stupidity.
-         */
-        set_tss_desc(cpu, t);
-
-        get_cpu_gdt_table(cpu)[GDT_ENTRY_TSS].type = 9;
-
-        syscall_init();                         /* This sets MSR_*STAR and related */
-        load_TR_desc();                         /* This does ltr */
-        load_LDT(&current->active_mm->context); /* This does lldt */
-
-        /*
-         * Now maybe reload the debug registers
-         */
-        if (current->thread.debugreg7){
-                loaddebug(&current->thread, 0);
-                loaddebug(&current->thread, 1);
-                loaddebug(&current->thread, 2);
-                loaddebug(&current->thread, 3);
-                /* no 4 and 5 */
-                loaddebug(&current->thread, 6);
-                loaddebug(&current->thread, 7);
-        }
-}
-
-#ifdef CONFIG_HIBERNATION
-/* Defined in arch/x86_64/kernel/suspend_asm.S */
-extern int restore_image(void);
-
-/*
- * Address to jump to in the last phase of restore in order to get to the image
- * kernel's text (this value is passed in the image header).
- */
-unsigned long restore_jump_address;
-
-/*
- * Value of the cr3 register from before the hibernation (this value is passed
- * in the image header).
- */
-unsigned long restore_cr3;
-
-pgd_t *temp_level4_pgt;
-
-void *relocated_restore_code;
-
-static int res_phys_pud_init(pud_t *pud, unsigned long address, unsigned long end)
-{
-        long i, j;
-
-        i = pud_index(address);
-        pud = pud + i;
-        for (; i < PTRS_PER_PUD; pud++, i++) {
-                unsigned long paddr;
-                pmd_t *pmd;
-
-                paddr = address + i*PUD_SIZE;
-                if (paddr >= end)
-                        break;
-
-                pmd = (pmd_t *)get_safe_page(GFP_ATOMIC);
-                if (!pmd)
-                        return -ENOMEM;
-                set_pud(pud, __pud(__pa(pmd) | _KERNPG_TABLE));
-                for (j = 0; j < PTRS_PER_PMD; pmd++, j++, paddr += PMD_SIZE) {
-                        unsigned long pe;
-
-                        if (paddr >= end)
-                                break;
-                        pe = __PAGE_KERNEL_LARGE_EXEC | paddr;
-                        pe &= __supported_pte_mask;
-                        set_pmd(pmd, __pmd(pe));
-                }
-        }
-        return 0;
-}
-
-static int set_up_temporary_mappings(void)
-{
-        unsigned long start, end, next;
-        int error;
-
-        temp_level4_pgt = (pgd_t *)get_safe_page(GFP_ATOMIC);
-        if (!temp_level4_pgt)
-                return -ENOMEM;
-
-        /* It is safe to reuse the original kernel mapping */
-        set_pgd(temp_level4_pgt + pgd_index(__START_KERNEL_map),
-                init_level4_pgt[pgd_index(__START_KERNEL_map)]);
-
-        /* Set up the direct mapping from scratch */
-        start = (unsigned long)pfn_to_kaddr(0);
-        end = (unsigned long)pfn_to_kaddr(end_pfn);
-
-        for (; start < end; start = next) {
-                pud_t *pud = (pud_t *)get_safe_page(GFP_ATOMIC);
-                if (!pud)
-                        return -ENOMEM;
-                next = start + PGDIR_SIZE;
-                if (next > end)
-                        next = end;
-                if ((error = res_phys_pud_init(pud, __pa(start), __pa(next))))
-                        return error;
-                set_pgd(temp_level4_pgt + pgd_index(start),
-                        mk_kernel_pgd(__pa(pud)));
-        }
-        return 0;
-}
-
-int swsusp_arch_resume(void)
-{
-        int error;
-
-        /* We have got enough memory and from now on we cannot recover */
-        if ((error = set_up_temporary_mappings()))
-                return error;
-
-        relocated_restore_code = (void *)get_safe_page(GFP_ATOMIC);
-        if (!relocated_restore_code)
-                return -ENOMEM;
-        memcpy(relocated_restore_code, &core_restore_code,
-               &restore_registers - &core_restore_code);
-
-        restore_image();
-        return 0;
-}
-
-/*
- *      pfn_is_nosave - check if given pfn is in the 'nosave' section
- */
-
-int pfn_is_nosave(unsigned long pfn)
-{
-        unsigned long nosave_begin_pfn = __pa_symbol(&__nosave_begin) >> PAGE_SHIFT;
-        unsigned long nosave_end_pfn = PAGE_ALIGN(__pa_symbol(&__nosave_end)) >> PAGE_SHIFT;
-        return (pfn >= nosave_begin_pfn) && (pfn < nosave_end_pfn);
-}
-
-struct restore_data_record {
-        unsigned long jump_address;
-        unsigned long cr3;
-        unsigned long magic;
-};
-
-#define RESTORE_MAGIC   0x0123456789ABCDEFUL
-
-/**
- *      arch_hibernation_header_save - populate the architecture specific part
- *              of a hibernation image header
- *      @addr: address to save the data at
- */
-int arch_hibernation_header_save(void *addr, unsigned int max_size)
-{
-        struct restore_data_record *rdr = addr;
-
-        if (max_size < sizeof(struct restore_data_record))
-                return -EOVERFLOW;
-        rdr->jump_address = restore_jump_address;
-        rdr->cr3 = restore_cr3;
-        rdr->magic = RESTORE_MAGIC;
-        return 0;
-}
-
-/**
- *      arch_hibernation_header_restore - read the architecture specific data
- *              from the hibernation image header
- *      @addr: address to read the data from
- */
-int arch_hibernation_header_restore(void *addr)
-{
-        struct restore_data_record *rdr = addr;
-
-        restore_jump_address = rdr->jump_address;
-        restore_cr3 = rdr->cr3;
-        return (rdr->magic == RESTORE_MAGIC) ? 0 : -EINVAL;
-}
-#endif /* CONFIG_HIBERNATION */
diff --git a/arch/x86/kernel/suspend_asm_64.S b/arch/x86/kernel/suspend_asm_64.S
deleted file mode 100644
index aeb9a4d7681e..000000000000
--- a/arch/x86/kernel/suspend_asm_64.S
+++ /dev/null
@@ -1,141 +0,0 @@
-/* Copyright 2004,2005 Pavel Machek <pavel@suse.cz>, Andi Kleen <ak@suse.de>, Rafael J. Wysocki <rjw@sisk.pl>
- *
- * Distribute under GPLv2.
- *
- * swsusp_arch_resume must not use any stack or any nonlocal variables while
- * copying pages:
- *
- * Its rewriting one kernel image with another. What is stack in "old"
- * image could very well be data page in "new" image, and overwriting
- * your own stack under you is bad idea.
- */
-        
-        .text
-#include <linux/linkage.h>
-#include <asm/segment.h>
-#include <asm/page.h>
-#include <asm/asm-offsets.h>
-
-ENTRY(swsusp_arch_suspend)
-        movq    $saved_context, %rax
-        movq    %rsp, pt_regs_sp(%rax)
-        movq    %rbp, pt_regs_bp(%rax)
-        movq    %rsi, pt_regs_si(%rax)
-        movq    %rdi, pt_regs_di(%rax)
-        movq    %rbx, pt_regs_bx(%rax)
-        movq    %rcx, pt_regs_cx(%rax)
-        movq    %rdx, pt_regs_dx(%rax)
-        movq    %r8, pt_regs_r8(%rax)
-        movq    %r9, pt_regs_r9(%rax)
-        movq    %r10, pt_regs_r10(%rax)
-        movq    %r11, pt_regs_r11(%rax)
-        movq    %r12, pt_regs_r12(%rax)
-        movq    %r13, pt_regs_r13(%rax)
-        movq    %r14, pt_regs_r14(%rax)
-        movq    %r15, pt_regs_r15(%rax)
-        pushfq
-        popq    pt_regs_flags(%rax)
-
-        /* save the address of restore_registers */
-        movq    $restore_registers, %rax
-        movq    %rax, restore_jump_address(%rip)
-        /* save cr3 */
-        movq    %cr3, %rax
-        movq    %rax, restore_cr3(%rip)
-
-        call swsusp_save
-        ret
-
-ENTRY(restore_image)
-        /* switch to temporary page tables */
-        movq    $__PAGE_OFFSET, %rdx
-        movq    temp_level4_pgt(%rip), %rax
-        subq    %rdx, %rax
-        movq    %rax, %cr3
-        /* Flush TLB */
-        movq    mmu_cr4_features(%rip), %rax
-        movq    %rax, %rdx
-        andq    $~(1<<7), %rdx  # PGE
-        movq    %rdx, %cr4;  # turn off PGE
-        movq    %cr3, %rcx;  # flush TLB
-        movq    %rcx, %cr3;
-        movq    %rax, %cr4;  # turn PGE back on
-
-        /* prepare to jump to the image kernel */
-        movq    restore_jump_address(%rip), %rax
-        movq    restore_cr3(%rip), %rbx
-
-        /* prepare to copy image data to their original locations */
-        movq    restore_pblist(%rip), %rdx
-        movq    relocated_restore_code(%rip), %rcx
-        jmpq    *%rcx
-
-        /* code below has been relocated to a safe page */
-ENTRY(core_restore_code)
-loop:
-        testq   %rdx, %rdx
-        jz      done
-
-        /* get addresses from the pbe and copy the page */
-        movq    pbe_address(%rdx), %rsi
-        movq    pbe_orig_address(%rdx), %rdi
-        movq    $(PAGE_SIZE >> 3), %rcx
-        rep
-        movsq
-
-        /* progress to the next pbe */
-        movq    pbe_next(%rdx), %rdx
-        jmp     loop
-done:
-        /* jump to the restore_registers address from the image header */
-        jmpq    *%rax
-        /*
-         * NOTE: This assumes that the boot kernel's text mapping covers the
-         * image kernel's page containing restore_registers and the address of
-         * this page is the same as in the image kernel's text mapping (it
-         * should always be true, because the text mapping is linear, starting
-         * from 0, and is supposed to cover the entire kernel text for every
-         * kernel).
-         *
-         * code below belongs to the image kernel
-         */
-
-ENTRY(restore_registers)
-        /* go back to the original page tables */
-        movq    %rbx, %cr3
-
-        /* Flush TLB, including "global" things (vmalloc) */
-        movq    mmu_cr4_features(%rip), %rax
-        movq    %rax, %rdx
-        andq    $~(1<<7), %rdx;  # PGE
-        movq    %rdx, %cr4;  # turn off PGE
-        movq    %cr3, %rcx;  # flush TLB
-        movq    %rcx, %cr3
-        movq    %rax, %cr4;  # turn PGE back on
-
-        /* We don't restore %rax, it must be 0 anyway */
-        movq    $saved_context, %rax
-        movq    pt_regs_sp(%rax), %rsp
-        movq    pt_regs_bp(%rax), %rbp
-        movq    pt_regs_si(%rax), %rsi
-        movq    pt_regs_di(%rax), %rdi
-        movq    pt_regs_bx(%rax), %rbx
-        movq    pt_regs_cx(%rax), %rcx
-        movq    pt_regs_dx(%rax), %rdx
-        movq    pt_regs_r8(%rax), %r8
-        movq    pt_regs_r9(%rax), %r9
-        movq    pt_regs_r10(%rax), %r10
-        movq    pt_regs_r11(%rax), %r11
-        movq    pt_regs_r12(%rax), %r12
-        movq    pt_regs_r13(%rax), %r13
-        movq    pt_regs_r14(%rax), %r14
-        movq    pt_regs_r15(%rax), %r15
-        pushq   pt_regs_flags(%rax)
-        popfq
-
-        xorq    %rax, %rax
-
-        /* tell the hibernation core that we've just restored the memory */
-        movq    %rax, in_suspend(%rip)
-
-        ret
diff --git a/arch/x86/kernel/topology.c b/arch/x86/kernel/topology.c
index e6757aaa202b..a40051b71d9b 100644
--- a/arch/x86/kernel/topology.c
+++ b/arch/x86/kernel/topology.c
@@ -53,7 +53,7 @@ EXPORT_SYMBOL(arch_register_cpu);
 
 void arch_unregister_cpu(int num)
 {
-        return unregister_cpu(&per_cpu(cpu_devices, num).cpu);
+        unregister_cpu(&per_cpu(cpu_devices, num).cpu);
 }
 EXPORT_SYMBOL(arch_unregister_cpu);
 #else