33 files changed, 530 insertions, 288 deletions

diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index 237fc128143d..6c70fed0f9a0 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -1259,7 +1259,7 @@ menuconfig APM
           machines with more than one CPU.
 
           In order to use APM, you will need supporting software. For location
-          and more information, read <file:Documentation/pm.txt> and the
+          and more information, read <file:Documentation/power/pm.txt> and the
           Battery Powered Linux mini-HOWTO, available from
           <http://www.tldp.org/docs.html#howto>.
 
diff --git a/arch/x86/kernel/aperture_64.c b/arch/x86/kernel/aperture_64.c
index 608152a2a05e..00df126169b4 100644
--- a/arch/x86/kernel/aperture_64.c
+++ b/arch/x86/kernel/aperture_64.c
@@ -18,6 +18,7 @@
 #include <linux/pci.h>
 #include <linux/bitops.h>
 #include <linux/ioport.h>
+#include <linux/suspend.h>
 #include <asm/e820.h>
 #include <asm/io.h>
 #include <asm/gart.h>
@@ -76,6 +77,8 @@ static u32 __init allocate_aperture(void)
         printk(KERN_INFO "Mapping aperture over %d KB of RAM @ %lx\n",
                         aper_size >> 10, __pa(p));
         insert_aperture_resource((u32)__pa(p), aper_size);
+        register_nosave_region((u32)__pa(p) >> PAGE_SHIFT,
+                                (u32)__pa(p+aper_size) >> PAGE_SHIFT);
 
         return (u32)__pa(p);
 }
diff --git a/arch/x86/kernel/cpu/cpufreq/speedstep-smi.c b/arch/x86/kernel/cpu/cpufreq/speedstep-smi.c
index f2b5a621d27b..8a85c93bd62a 100644
--- a/arch/x86/kernel/cpu/cpufreq/speedstep-smi.c
+++ b/arch/x86/kernel/cpu/cpufreq/speedstep-smi.c
@@ -63,7 +63,7 @@ static struct cpufreq_frequency_table speedstep_freqs[] = {
  */
 static int speedstep_smi_ownership (void)
 {
-        u32 command, result, magic;
+        u32 command, result, magic, dummy;
         u32 function = GET_SPEEDSTEP_OWNER;
         unsigned char magic_data[] = "Copyright (c) 1999 Intel Corporation";
 
@@ -73,8 +73,11 @@ static int speedstep_smi_ownership (void)
         dprintk("trying to obtain ownership with command %x at port %x\n", command, smi_port);
 
         __asm__ __volatile__(
+                "push %%ebp\n"
                 "out %%al, (%%dx)\n"
-                : "=D" (result)
+                "pop %%ebp\n"
+                : "=D" (result), "=a" (dummy), "=b" (dummy), "=c" (dummy), "=d" (dummy),
+                        "=S" (dummy)
                 : "a" (command), "b" (function), "c" (0), "d" (smi_port),
                         "D" (0), "S" (magic)
                 : "memory"
@@ -96,7 +99,7 @@ static int speedstep_smi_ownership (void)
  */
 static int speedstep_smi_get_freqs (unsigned int *low, unsigned int *high)
 {
-        u32 command, result = 0, edi, high_mhz, low_mhz;
+        u32 command, result = 0, edi, high_mhz, low_mhz, dummy;
         u32 state=0;
         u32 function = GET_SPEEDSTEP_FREQS;
 
@@ -109,10 +112,12 @@ static int speedstep_smi_get_freqs (unsigned int *low, unsigned int *high)
 
         dprintk("trying to determine frequencies with command %x at port %x\n", command, smi_port);
 
-        __asm__ __volatile__("movl $0, %%edi\n"
+        __asm__ __volatile__(
+                "push %%ebp\n"
                 "out %%al, (%%dx)\n"
-                : "=a" (result), "=b" (high_mhz), "=c" (low_mhz), "=d" (state), "=D" (edi)
-                : "a" (command), "b" (function), "c" (state), "d" (smi_port), "S" (0)
+                "pop %%ebp"
+                : "=a" (result), "=b" (high_mhz), "=c" (low_mhz), "=d" (state), "=D" (edi), "=S" (dummy)
+                : "a" (command), "b" (function), "c" (state), "d" (smi_port), "S" (0), "D" (0)
         );
 
         dprintk("result %x, low_freq %u, high_freq %u\n", result, low_mhz, high_mhz);
@@ -135,16 +140,18 @@ static int speedstep_smi_get_freqs (unsigned int *low, unsigned int *high)
 static int speedstep_get_state (void)
 {
         u32 function=GET_SPEEDSTEP_STATE;
-        u32 result, state, edi, command;
+        u32 result, state, edi, command, dummy;
 
         command = (smi_sig & 0xffffff00) | (smi_cmd & 0xff);
 
         dprintk("trying to determine current setting with command %x at port %x\n", command, smi_port);
 
-        __asm__ __volatile__("movl $0, %%edi\n"
+        __asm__ __volatile__(
+                "push %%ebp\n"
                 "out %%al, (%%dx)\n"
-                : "=a" (result), "=b" (state), "=D" (edi)
-                : "a" (command), "b" (function), "c" (0), "d" (smi_port), "S" (0)
+                "pop %%ebp\n"
+                : "=a" (result), "=b" (state), "=D" (edi), "=c" (dummy), "=d" (dummy), "=S" (dummy)
+                : "a" (command), "b" (function), "c" (0), "d" (smi_port), "S" (0), "D" (0)
         );
 
         dprintk("state is %x, result is %x\n", state, result);
@@ -160,7 +167,7 @@ static int speedstep_get_state (void)
  */
 static void speedstep_set_state (unsigned int state)
 {
-        unsigned int result = 0, command, new_state;
+        unsigned int result = 0, command, new_state, dummy;
         unsigned long flags;
         unsigned int function=SET_SPEEDSTEP_STATE;
         unsigned int retry = 0;
@@ -182,10 +189,12 @@ static void speedstep_set_state (unsigned int state)
                 }
                 retry++;
                 __asm__ __volatile__(
-                        "movl $0, %%edi\n"
+                        "push %%ebp\n"
                         "out %%al, (%%dx)\n"
-                        : "=b" (new_state), "=D" (result)
-                        : "a" (command), "b" (function), "c" (state), "d" (smi_port), "S" (0)
+                        "pop %%ebp"
+                        : "=b" (new_state), "=D" (result), "=c" (dummy), "=a" (dummy),
+                                "=d" (dummy), "=S" (dummy)
+                        : "a" (command), "b" (function), "c" (state), "d" (smi_port), "S" (0), "D" (0)
                         );
         } while ((new_state != state) && (retry <= SMI_TRIES));
 
@@ -195,7 +204,7 @@ static void speedstep_set_state (unsigned int state)
         if (new_state == state) {
                 dprintk("change to %u MHz succeeded after %u tries with result %u\n", (speedstep_freqs[new_state].frequency / 1000), retry, result);
         } else {
-                printk(KERN_ERR "cpufreq: change failed with new_state %u and result %u\n", new_state, result);
+                printk(KERN_ERR "cpufreq: change to state %u failed with new_state %u and result %u\n", state, new_state, result);
         }
 
         return;
diff --git a/arch/x86/kernel/cpu/mtrr/generic.c b/arch/x86/kernel/cpu/mtrr/generic.c
index 103d61a59b19..3e18db4cefee 100644
--- a/arch/x86/kernel/cpu/mtrr/generic.c
+++ b/arch/x86/kernel/cpu/mtrr/generic.c
@@ -176,12 +176,13 @@ static inline void k8_enable_fixed_iorrs(void)
 }
 
 /**
- * Checks and updates an fixed-range MTRR if it differs from the value it
- * should have. If K8 extentions are wanted, update the K8 SYSCFG MSR also.
- * see AMD publication no. 24593, chapter 7.8.1, page 233 for more information
- * \param msr MSR address of the MTTR which should be checked and updated
- * \param changed pointer which indicates whether the MTRR needed to be changed
- * \param msrwords pointer to the MSR values which the MSR should have
+ * set_fixed_range - checks & updates a fixed-range MTRR if it differs from the value it should have
+ * @msr: MSR address of the MTTR which should be checked and updated
+ * @changed: pointer which indicates whether the MTRR needed to be changed
+ * @msrwords: pointer to the MSR values which the MSR should have
+ *
+ * If K8 extentions are wanted, update the K8 SYSCFG MSR also.
+ * See AMD publication no. 24593, chapter 7.8.1, page 233 for more information.
  */
 static void set_fixed_range(int msr, bool *changed, unsigned int *msrwords)
 {
@@ -199,12 +200,15 @@ static void set_fixed_range(int msr, bool *changed, unsigned int *msrwords)
         }
 }
 
+/**
+ * generic_get_free_region - Get a free MTRR.
+ * @base: The starting (base) address of the region.
+ * @size: The size (in bytes) of the region.
+ * @replace_reg: mtrr index to be replaced; set to invalid value if none.
+ *
+ * Returns: The index of the region on success, else negative on error.
+ */
 int generic_get_free_region(unsigned long base, unsigned long size, int replace_reg)
-/*  [SUMMARY] Get a free MTRR.
-    <base> The starting (base) address of the region.
-    <size> The size (in bytes) of the region.
-    [RETURNS] The index of the region on success, else -1 on error.
-*/
 {
         int i, max;
         mtrr_type ltype;
@@ -249,8 +253,8 @@ static void generic_get_mtrr(unsigned int reg, unsigned long *base,
 }
 
 /**
- * Checks and updates the fixed-range MTRRs if they differ from the saved set
- * \param frs pointer to fixed-range MTRR values, saved by get_fixed_ranges()
+ * set_fixed_ranges - checks & updates the fixed-range MTRRs if they differ from the saved set
+ * @frs: pointer to fixed-range MTRR values, saved by get_fixed_ranges()
  */
 static int set_fixed_ranges(mtrr_type * frs)
 {
@@ -294,13 +298,13 @@ static bool set_mtrr_var_ranges(unsigned int index, struct mtrr_var_range *vr)
 
 static u32 deftype_lo, deftype_hi;
 
+/**
+ * set_mtrr_state - Set the MTRR state for this CPU.
+ *
+ * NOTE: The CPU must already be in a safe state for MTRR changes.
+ * RETURNS: 0 if no changes made, else a mask indicating what was changed.
+ */
 static unsigned long set_mtrr_state(void)
-/*  [SUMMARY] Set the MTRR state for this CPU.
-    <state> The MTRR state information to read.
-    <ctxt> Some relevant CPU context.
-    [NOTE] The CPU must already be in a safe state for MTRR changes.
-    [RETURNS] 0 if no changes made, else a mask indication what was changed.
-*/
 {
         unsigned int i;
         unsigned long change_mask = 0;
diff --git a/arch/x86/kernel/cpu/mtrr/main.c b/arch/x86/kernel/cpu/mtrr/main.c
index be83336fddba..a6450b3ae759 100644
--- a/arch/x86/kernel/cpu/mtrr/main.c
+++ b/arch/x86/kernel/cpu/mtrr/main.c
@@ -711,7 +711,8 @@ int __init mtrr_trim_uncached_memory(unsigned long end_pfn)
                 trim_size = end_pfn;
                 trim_size <<= PAGE_SHIFT;
                 trim_size -= trim_start;
-                add_memory_region(trim_start, trim_size, E820_RESERVED);
+                update_memory_range(trim_start, trim_size, E820_RAM,
+                                        E820_RESERVED);
                 update_e820();
                 return 1;
         }
diff --git a/arch/x86/kernel/e820_32.c b/arch/x86/kernel/e820_32.c
index 4e16ef4a2659..80444c5c9b14 100644
--- a/arch/x86/kernel/e820_32.c
+++ b/arch/x86/kernel/e820_32.c
@@ -749,6 +749,32 @@ static int __init parse_memmap(char *arg)
         return 0;
 }
 early_param("memmap", parse_memmap);
+void __init update_memory_range(u64 start, u64 size, unsigned old_type,
+                                unsigned new_type)
+{
+        int i;
+
+        BUG_ON(old_type == new_type);
+
+        for (i = 0; i < e820.nr_map; i++) {
+                struct e820entry *ei = &e820.map[i];
+                u64 final_start, final_end;
+                if (ei->type != old_type)
+                        continue;
+                /* totally covered? */
+                if (ei->addr >= start && ei->size <= size) {
+                        ei->type = new_type;
+                        continue;
+                }
+                /* partially covered */
+                final_start = max(start, ei->addr);
+                final_end = min(start + size, ei->addr + ei->size);
+                if (final_start >= final_end)
+                        continue;
+                add_memory_region(final_start, final_end - final_start,
+                                         new_type);
+        }
+}
 void __init update_e820(void)
 {
         u8 nr_map;
diff --git a/arch/x86/kernel/e820_64.c b/arch/x86/kernel/e820_64.c
index 9f65b4cc323c..9be697126013 100644
--- a/arch/x86/kernel/e820_64.c
+++ b/arch/x86/kernel/e820_64.c
@@ -744,6 +744,33 @@ void __init finish_e820_parsing(void)
         }
 }
 
+void __init update_memory_range(u64 start, u64 size, unsigned old_type,
+                                unsigned new_type)
+{
+        int i;
+
+        BUG_ON(old_type == new_type);
+
+        for (i = 0; i < e820.nr_map; i++) {
+                struct e820entry *ei = &e820.map[i];
+                u64 final_start, final_end;
+                if (ei->type != old_type)
+                        continue;
+                /* totally covered? */
+                if (ei->addr >= start && ei->size <= size) {
+                        ei->type = new_type;
+                        continue;
+                }
+                /* partially covered */
+                final_start = max(start, ei->addr);
+                final_end = min(start + size, ei->addr + ei->size);
+                if (final_start >= final_end)
+                        continue;
+                add_memory_region(final_start, final_end - final_start,
+                                         new_type);
+        }
+}
+
 void __init update_e820(void)
 {
         u8 nr_map;
diff --git a/arch/x86/kernel/head_32.S b/arch/x86/kernel/head_32.S
index fd8ca53943a8..74d87ea85b5c 100644
--- a/arch/x86/kernel/head_32.S
+++ b/arch/x86/kernel/head_32.S
@@ -657,7 +657,7 @@ int_msg:
         .asciz "Unknown interrupt or fault at EIP %p %p %p\n"
 
 fault_msg:
-        .ascii                                                          \
+        .asciz                                                          \
 /* fault info: */       "BUG: Int %d: CR2 %p\n"                         \
 /* pusha regs: */       "     EDI %p  ESI %p  EBP %p  ESP %p\n"         \
                         "     EBX %p  EDX %p  ECX %p  EAX %p\n"         \
diff --git a/arch/x86/kernel/io_delay.c b/arch/x86/kernel/io_delay.c
index c706a3061553..5921e5f0a640 100644
--- a/arch/x86/kernel/io_delay.c
+++ b/arch/x86/kernel/io_delay.c
@@ -78,6 +78,14 @@ static struct dmi_system_id __initdata io_delay_0xed_port_dmi_table[] = {
         },
         {
                 .callback       = dmi_io_delay_0xed_port,
+                .ident          = "HP Pavilion dv6000",
+                .matches        = {
+                        DMI_MATCH(DMI_BOARD_VENDOR, "Quanta"),
+                        DMI_MATCH(DMI_BOARD_NAME, "30B8")
+                }
+        },
+        {
+                .callback       = dmi_io_delay_0xed_port,
                 .ident          = "HP Pavilion tx1000",
                 .matches        = {
                         DMI_MATCH(DMI_BOARD_VENDOR, "Quanta"),
diff --git a/arch/x86/kernel/mfgpt_32.c b/arch/x86/kernel/mfgpt_32.c
index 027fc067b399..b402c0f3f192 100644
--- a/arch/x86/kernel/mfgpt_32.c
+++ b/arch/x86/kernel/mfgpt_32.c
@@ -30,6 +30,7 @@
 
 #include <linux/kernel.h>
 #include <linux/interrupt.h>
+#include <linux/module.h>
 #include <asm/geode.h>
 
 static struct mfgpt_timer_t {
diff --git a/arch/x86/kernel/pci-dma_64.c b/arch/x86/kernel/pci-dma_64.c
index a82473d192a3..375cb2bc45be 100644
--- a/arch/x86/kernel/pci-dma_64.c
+++ b/arch/x86/kernel/pci-dma_64.c
@@ -53,11 +53,6 @@ dma_alloc_pages(struct device *dev, gfp_t gfp, unsigned order)
         int node;
 
         node = dev_to_node(dev);
-        if (node == -1)
-                node = numa_node_id();
-
-        if (node < first_node(node_online_map))
-                node = first_node(node_online_map);
 
         page = alloc_pages_node(node, gfp, order);
         return page ? page_address(page) : NULL;
diff --git a/arch/x86/kernel/ptrace.c b/arch/x86/kernel/ptrace.c
index d5904eef1d31..eb92ccbb3502 100644
--- a/arch/x86/kernel/ptrace.c
+++ b/arch/x86/kernel/ptrace.c
@@ -600,21 +600,6 @@ static int ptrace_bts_read_record(struct task_struct *child,
         return sizeof(ret);
 }
 
-static int ptrace_bts_write_record(struct task_struct *child,
-                                   const struct bts_struct *in)
-{
-        int retval;
-
-        if (!child->thread.ds_area_msr)
-                return -ENXIO;
-
-        retval = ds_write_bts((void *)child->thread.ds_area_msr, in);
-        if (retval)
-                return retval;
-
-        return sizeof(*in);
-}
-
 static int ptrace_bts_clear(struct task_struct *child)
 {
         if (!child->thread.ds_area_msr)
@@ -657,75 +642,6 @@ static int ptrace_bts_drain(struct task_struct *child,
         return end;
 }
 
-static int ptrace_bts_realloc(struct task_struct *child,
-                              int size, int reduce_size)
-{
-        unsigned long rlim, vm;
-        int ret, old_size;
-
-        if (size < 0)
-                return -EINVAL;
-
-        old_size = ds_get_bts_size((void *)child->thread.ds_area_msr);
-        if (old_size < 0)
-                return old_size;
-
-        ret = ds_free((void **)&child->thread.ds_area_msr);
-        if (ret < 0)
-                goto out;
-
-        size >>= PAGE_SHIFT;
-        old_size >>= PAGE_SHIFT;
-
-        current->mm->total_vm  -= old_size;
-        current->mm->locked_vm -= old_size;
-
-        if (size == 0)
-                goto out;
-
-        rlim = current->signal->rlim[RLIMIT_AS].rlim_cur >> PAGE_SHIFT;
-        vm = current->mm->total_vm  + size;
-        if (rlim < vm) {
-                ret = -ENOMEM;
-
-                if (!reduce_size)
-                        goto out;
-
-                size = rlim - current->mm->total_vm;
-                if (size <= 0)
-                        goto out;
-        }
-
-        rlim = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur >> PAGE_SHIFT;
-        vm = current->mm->locked_vm  + size;
-        if (rlim < vm) {
-                ret = -ENOMEM;
-
-                if (!reduce_size)
-                        goto out;
-
-                size = rlim - current->mm->locked_vm;
-                if (size <= 0)
-                        goto out;
-        }
-
-        ret = ds_allocate((void **)&child->thread.ds_area_msr,
-                          size << PAGE_SHIFT);
-        if (ret < 0)
-                goto out;
-
-        current->mm->total_vm  += size;
-        current->mm->locked_vm += size;
-
-out:
-        if (child->thread.ds_area_msr)
-                set_tsk_thread_flag(child, TIF_DS_AREA_MSR);
-        else
-                clear_tsk_thread_flag(child, TIF_DS_AREA_MSR);
-
-        return ret;
-}
-
 static int ptrace_bts_config(struct task_struct *child,
                              long cfg_size,
                              const struct ptrace_bts_config __user *ucfg)
@@ -828,6 +744,91 @@ static int ptrace_bts_status(struct task_struct *child,
         return sizeof(cfg);
 }
 
+
+static int ptrace_bts_write_record(struct task_struct *child,
+                                   const struct bts_struct *in)
+{
+        int retval;
+
+        if (!child->thread.ds_area_msr)
+                return -ENXIO;
+
+        retval = ds_write_bts((void *)child->thread.ds_area_msr, in);
+        if (retval)
+                return retval;
+
+        return sizeof(*in);
+}
+
+static int ptrace_bts_realloc(struct task_struct *child,
+                              int size, int reduce_size)
+{
+        unsigned long rlim, vm;
+        int ret, old_size;
+
+        if (size < 0)
+                return -EINVAL;
+
+        old_size = ds_get_bts_size((void *)child->thread.ds_area_msr);
+        if (old_size < 0)
+                return old_size;
+
+        ret = ds_free((void **)&child->thread.ds_area_msr);
+        if (ret < 0)
+                goto out;
+
+        size >>= PAGE_SHIFT;
+        old_size >>= PAGE_SHIFT;
+
+        current->mm->total_vm  -= old_size;
+        current->mm->locked_vm -= old_size;
+
+        if (size == 0)
+                goto out;
+
+        rlim = current->signal->rlim[RLIMIT_AS].rlim_cur >> PAGE_SHIFT;
+        vm = current->mm->total_vm  + size;
+        if (rlim < vm) {
+                ret = -ENOMEM;
+
+                if (!reduce_size)
+                        goto out;
+
+                size = rlim - current->mm->total_vm;
+                if (size <= 0)
+                        goto out;
+        }
+
+        rlim = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur >> PAGE_SHIFT;
+        vm = current->mm->locked_vm  + size;
+        if (rlim < vm) {
+                ret = -ENOMEM;
+
+                if (!reduce_size)
+                        goto out;
+
+                size = rlim - current->mm->locked_vm;
+                if (size <= 0)
+                        goto out;
+        }
+
+        ret = ds_allocate((void **)&child->thread.ds_area_msr,
+                          size << PAGE_SHIFT);
+        if (ret < 0)
+                goto out;
+
+        current->mm->total_vm  += size;
+        current->mm->locked_vm += size;
+
+out:
+        if (child->thread.ds_area_msr)
+                set_tsk_thread_flag(child, TIF_DS_AREA_MSR);
+        else
+                clear_tsk_thread_flag(child, TIF_DS_AREA_MSR);
+
+        return ret;
+}
+
 void ptrace_bts_take_timestamp(struct task_struct *tsk,
                                enum bts_qualifier qualifier)
 {
diff --git a/arch/x86/kernel/quirks.c b/arch/x86/kernel/quirks.c
index c47208fc5932..d89a648fe710 100644
--- a/arch/x86/kernel/quirks.c
+++ b/arch/x86/kernel/quirks.c
@@ -363,6 +363,8 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0051,
                         nvidia_force_enable_hpet);
 
 /* LPC bridges */
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0260,
+                        nvidia_force_enable_hpet);
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0360,
                         nvidia_force_enable_hpet);
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0361,
diff --git a/arch/x86/kernel/reboot.c b/arch/x86/kernel/reboot.c
index 55ceb8cdef75..484c4a80d38a 100644
--- a/arch/x86/kernel/reboot.c
+++ b/arch/x86/kernel/reboot.c
@@ -152,6 +152,24 @@ static struct dmi_system_id __initdata reboot_dmi_table[] = {
                         DMI_MATCH(DMI_BOARD_NAME, "0WF810"),
                 },
         },
+        {       /* Handle problems with rebooting on Dell Optiplex 745's DFF*/
+                .callback = set_bios_reboot,
+                .ident = "Dell OptiPlex 745",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"),
+                        DMI_MATCH(DMI_BOARD_NAME, "0MM599"),
+                },
+        },
+        {       /* Handle problems with rebooting on Dell Optiplex 745 with 0KW626 */
+                .callback = set_bios_reboot,
+                .ident = "Dell OptiPlex 745",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"),
+                        DMI_MATCH(DMI_BOARD_NAME, "0KW626"),
+                },
+        },
         {       /* Handle problems with rebooting on Dell 2400's */
                 .callback = set_bios_reboot,
                 .ident = "Dell PowerEdge 2400",
diff --git a/arch/x86/kernel/setup64.c b/arch/x86/kernel/setup64.c
index 309366f8f603..e24c45677094 100644
--- a/arch/x86/kernel/setup64.c
+++ b/arch/x86/kernel/setup64.c
@@ -142,14 +142,16 @@ void __init setup_per_cpu_areas(void)
         printk(KERN_INFO "PERCPU: Allocating %lu bytes of per cpu data\n", size);
         for_each_cpu_mask (i, cpu_possible_map) {
                 char *ptr;
+#ifndef CONFIG_NEED_MULTIPLE_NODES
+                ptr = alloc_bootmem_pages(size);
+#else
+                int node = early_cpu_to_node(i);
 
-                if (!NODE_DATA(early_cpu_to_node(i))) {
-                        printk("cpu with no node %d, num_online_nodes %d\n",
-                               i, num_online_nodes());
+                if (!node_online(node) || !NODE_DATA(node))
                         ptr = alloc_bootmem_pages(size);
-                } else { 
-                        ptr = alloc_bootmem_pages_node(NODE_DATA(early_cpu_to_node(i)), size);
-                }
+                else
+                        ptr = alloc_bootmem_pages_node(NODE_DATA(node), size);
+#endif
                 if (!ptr)
                         panic("Cannot allocate cpu data for CPU %d\n", i);
                 cpu_pda(i)->data_offset = ptr - __per_cpu_start;
diff --git a/arch/x86/kernel/setup_32.c b/arch/x86/kernel/setup_32.c
index a1d7071a51c9..2b3e5d45176b 100644
--- a/arch/x86/kernel/setup_32.c
+++ b/arch/x86/kernel/setup_32.c
@@ -406,8 +406,6 @@ static unsigned long __init setup_memory(void)
          */
         min_low_pfn = PFN_UP(init_pg_tables_end);
 
-        find_max_pfn();
-
         max_low_pfn = find_max_low_pfn();
 
 #ifdef CONFIG_HIGHMEM
@@ -764,12 +762,13 @@ void __init setup_arch(char **cmdline_p)
         if (efi_enabled)
                 efi_init();
 
-        max_low_pfn = setup_memory();
-
         /* update e820 for memory not covered by WB MTRRs */
+        find_max_pfn();
         mtrr_bp_init();
         if (mtrr_trim_uncached_memory(max_pfn))
-                max_low_pfn = setup_memory();
+                find_max_pfn();
+
+        max_low_pfn = setup_memory();
 
 #ifdef CONFIG_VMI
         /*
diff --git a/arch/x86/kernel/setup_64.c b/arch/x86/kernel/setup_64.c
index 7637dc91c79b..f4f7ecfb898c 100644
--- a/arch/x86/kernel/setup_64.c
+++ b/arch/x86/kernel/setup_64.c
@@ -801,7 +801,7 @@ static void __cpuinit srat_detect_node(void)
         /* Don't do the funky fallback heuristics the AMD version employs
            for now. */
         node = apicid_to_node[apicid];
-        if (node == NUMA_NO_NODE)
+        if (node == NUMA_NO_NODE || !node_online(node))
                 node = first_node(node_online_map);
         numa_set_node(cpu, node);
 
diff --git a/arch/x86/kvm/mmu.c b/arch/x86/kvm/mmu.c
index d8172aabc660..e55af12e11b7 100644
--- a/arch/x86/kvm/mmu.c
+++ b/arch/x86/kvm/mmu.c
@@ -222,8 +222,7 @@ static int is_io_pte(unsigned long pte)
 
 static int is_rmap_pte(u64 pte)
 {
-        return pte != shadow_trap_nonpresent_pte
-                && pte != shadow_notrap_nonpresent_pte;
+        return is_shadow_present_pte(pte);
 }
 
 static gfn_t pse36_gfn_delta(u32 gpte)
@@ -893,14 +892,25 @@ static void mmu_set_spte(struct kvm_vcpu *vcpu, u64 *shadow_pte,
                          int *ptwrite, gfn_t gfn, struct page *page)
 {
         u64 spte;
-        int was_rmapped = is_rmap_pte(*shadow_pte);
+        int was_rmapped = 0;
         int was_writeble = is_writeble_pte(*shadow_pte);
+        hfn_t host_pfn = (*shadow_pte & PT64_BASE_ADDR_MASK) >> PAGE_SHIFT;
 
         pgprintk("%s: spte %llx access %x write_fault %d"
                  " user_fault %d gfn %lx\n",
                  __FUNCTION__, *shadow_pte, pt_access,
                  write_fault, user_fault, gfn);
 
+        if (is_rmap_pte(*shadow_pte)) {
+                if (host_pfn != page_to_pfn(page)) {
+                        pgprintk("hfn old %lx new %lx\n",
+                                 host_pfn, page_to_pfn(page));
+                        rmap_remove(vcpu->kvm, shadow_pte);
+                }
+                else
+                        was_rmapped = 1;
+        }
+
         /*
          * We don't set the accessed bit, since we sometimes want to see
          * whether the guest actually used the pte (in order to detect
@@ -1402,7 +1412,7 @@ static void mmu_guess_page_from_pte_write(struct kvm_vcpu *vcpu, gpa_t gpa,
         up_read(&current->mm->mmap_sem);
 
         vcpu->arch.update_pte.gfn = gfn;
-        vcpu->arch.update_pte.page = gfn_to_page(vcpu->kvm, gfn);
+        vcpu->arch.update_pte.page = page;
 }
 
 void kvm_mmu_pte_write(struct kvm_vcpu *vcpu, gpa_t gpa,
diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c
index 94ea724638fd..8e1462880d1f 100644
--- a/arch/x86/kvm/vmx.c
+++ b/arch/x86/kvm/vmx.c
@@ -349,8 +349,6 @@ static void update_exception_bitmap(struct kvm_vcpu *vcpu)
 
 static void reload_tss(void)
 {
-#ifndef CONFIG_X86_64
-
         /*
          * VT restores TR but not its size.  Useless.
          */
@@ -361,7 +359,6 @@ static void reload_tss(void)
         descs = (void *)gdt.base;
         descs[GDT_ENTRY_TSS].type = 9; /* available TSS */
         load_TR_desc();
-#endif
 }
 
 static void load_transition_efer(struct vcpu_vmx *vmx)
@@ -1436,7 +1433,7 @@ static int init_rmode_tss(struct kvm *kvm)
         int ret = 0;
         int r;
 
-        down_read(&current->mm->mmap_sem);
+        down_read(&kvm->slots_lock);
         r = kvm_clear_guest_page(kvm, fn, 0, PAGE_SIZE);
         if (r < 0)
                 goto out;
@@ -1459,7 +1456,7 @@ static int init_rmode_tss(struct kvm *kvm)
 
         ret = 1;
 out:
-        up_read(&current->mm->mmap_sem);
+        up_read(&kvm->slots_lock);
         return ret;
 }
 
diff --git a/arch/x86/lguest/boot.c b/arch/x86/lguest/boot.c
index a104c532ff70..3335b4595efd 100644
--- a/arch/x86/lguest/boot.c
+++ b/arch/x86/lguest/boot.c
@@ -10,21 +10,19 @@
  * (such as the example in Documentation/lguest/lguest.c) is called the
  * Launcher.
  *
- * Secondly, we only run specially modified Guests, not normal kernels.  When
- * you set CONFIG_LGUEST to 'y' or 'm', this automatically sets
- * CONFIG_LGUEST_GUEST=y, which compiles this file into the kernel so it knows
- * how to be a Guest.  This means that you can use the same kernel you boot
- * normally (ie. as a Host) as a Guest.
+ * Secondly, we only run specially modified Guests, not normal kernels: setting
+ * CONFIG_LGUEST_GUEST to "y" compiles this file into the kernel so it knows
+ * how to be a Guest at boot time.  This means that you can use the same kernel
+ * you boot normally (ie. as a Host) as a Guest.
  *
  * These Guests know that they cannot do privileged operations, such as disable
  * interrupts, and that they have to ask the Host to do such things explicitly.
  * This file consists of all the replacements for such low-level native
  * hardware operations: these special Guest versions call the Host.
  *
- * So how does the kernel know it's a Guest?  The Guest starts at a special
- * entry point marked with a magic string, which sets up a few things then
- * calls here.  We replace the native functions various "paravirt" structures
- * with our Guest versions, then boot like normal. :*/
+ * So how does the kernel know it's a Guest?  We'll see that later, but let's
+ * just say that we end up here where we replace the native functions various
+ * "paravirt" structures with our Guest versions, then boot like normal. :*/
 
 /*
  * Copyright (C) 2006, Rusty Russell <rusty@rustcorp.com.au> IBM Corporation.
@@ -134,7 +132,7 @@ static void async_hcall(unsigned long call, unsigned long arg1,
  * lguest_leave_lazy_mode().
  *
  * So, when we're in lazy mode, we call async_hcall() to store the call for
- * future processing. */
+ * future processing: */
 static void lazy_hcall(unsigned long call,
                        unsigned long arg1,
                        unsigned long arg2,
@@ -147,7 +145,7 @@ static void lazy_hcall(unsigned long call,
 }
 
 /* When lazy mode is turned off reset the per-cpu lazy mode variable and then
- * issue a hypercall to flush any stored calls. */
+ * issue the do-nothing hypercall to flush any stored calls. */
 static void lguest_leave_lazy_mode(void)
 {
         paravirt_leave_lazy(paravirt_get_lazy_mode());
@@ -164,7 +162,7 @@ static void lguest_leave_lazy_mode(void)
  *
  * So instead we keep an "irq_enabled" field inside our "struct lguest_data",
  * which the Guest can update with a single instruction.  The Host knows to
- * check there when it wants to deliver an interrupt.
+ * check there before it tries to deliver an interrupt.
  */
 
 /* save_flags() is expected to return the processor state (ie. "flags").  The
@@ -196,10 +194,15 @@ static void irq_enable(void)
 /*M:003 Note that we don't check for outstanding interrupts when we re-enable
  * them (or when we unmask an interrupt).  This seems to work for the moment,
  * since interrupts are rare and we'll just get the interrupt on the next timer
- * tick, but when we turn on CONFIG_NO_HZ, we should revisit this.  One way
+ * tick, but now we can run with CONFIG_NO_HZ, we should revisit this.  One way
  * would be to put the "irq_enabled" field in a page by itself, and have the
  * Host write-protect it when an interrupt comes in when irqs are disabled.
- * There will then be a page fault as soon as interrupts are re-enabled. :*/
+ * There will then be a page fault as soon as interrupts are re-enabled.
+ *
+ * A better method is to implement soft interrupt disable generally for x86:
+ * instead of disabling interrupts, we set a flag.  If an interrupt does come
+ * in, we then disable them for real.  This is uncommon, so we could simply use
+ * a hypercall for interrupt control and not worry about efficiency. :*/
 
 /*G:034
  * The Interrupt Descriptor Table (IDT).
@@ -212,6 +215,10 @@ static void irq_enable(void)
 static void lguest_write_idt_entry(gate_desc *dt,
                                    int entrynum, const gate_desc *g)
 {
+        /* The gate_desc structure is 8 bytes long: we hand it to the Host in
+         * two 32-bit chunks.  The whole 32-bit kernel used to hand descriptors
+         * around like this; typesafety wasn't a big concern in Linux's early
+         * years. */
         u32 *desc = (u32 *)g;
         /* Keep the local copy up to date. */
         native_write_idt_entry(dt, entrynum, g);
@@ -243,7 +250,8 @@ static void lguest_load_idt(const struct desc_ptr *desc)
  *
  * This is the opposite of the IDT code where we have a LOAD_IDT_ENTRY
  * hypercall and use that repeatedly to load a new IDT.  I don't think it
- * really matters, but wouldn't it be nice if they were the same?
+ * really matters, but wouldn't it be nice if they were the same?  Wouldn't
+ * it be even better if you were the one to send the patch to fix it?
  */
 static void lguest_load_gdt(const struct desc_ptr *desc)
 {
@@ -298,9 +306,9 @@ static void lguest_load_tr_desc(void)
 
 /* The "cpuid" instruction is a way of querying both the CPU identity
  * (manufacturer, model, etc) and its features.  It was introduced before the
- * Pentium in 1993 and keeps getting extended by both Intel and AMD.  As you
- * might imagine, after a decade and a half this treatment, it is now a giant
- * ball of hair.  Its entry in the current Intel manual runs to 28 pages.
+ * Pentium in 1993 and keeps getting extended by both Intel, AMD and others.
+ * As you might imagine, after a decade and a half this treatment, it is now a
+ * giant ball of hair.  Its entry in the current Intel manual runs to 28 pages.
  *
  * This instruction even it has its own Wikipedia entry.  The Wikipedia entry
  * has been translated into 4 languages.  I am not making this up!
@@ -594,17 +602,17 @@ static unsigned long lguest_get_wallclock(void)
         return lguest_data.time.tv_sec;
 }
 
-/* The TSC is a Time Stamp Counter.  The Host tells us what speed it runs at,
- * or 0 if it's unusable as a reliable clock source.  This matches what we want
- * here: if we return 0 from this function, the x86 TSC clock will not register
- * itself. */
+/* The TSC is an Intel thing called the Time Stamp Counter.  The Host tells us
+ * what speed it runs at, or 0 if it's unusable as a reliable clock source.
+ * This matches what we want here: if we return 0 from this function, the x86
+ * TSC clock will give up and not register itself. */
 static unsigned long lguest_cpu_khz(void)
 {
         return lguest_data.tsc_khz;
 }
 
-/* If we can't use the TSC, the kernel falls back to our "lguest_clock", where
- * we read the time value given to us by the Host. */
+/* If we can't use the TSC, the kernel falls back to our lower-priority
+ * "lguest_clock", where we read the time value given to us by the Host. */
 static cycle_t lguest_clock_read(void)
 {
         unsigned long sec, nsec;
@@ -648,12 +656,16 @@ static struct clocksource lguest_clock = {
 static int lguest_clockevent_set_next_event(unsigned long delta,
                                            struct clock_event_device *evt)
 {
+        /* FIXME: I don't think this can ever happen, but James tells me he had
+         * to put this code in.  Maybe we should remove it now.  Anyone? */
         if (delta < LG_CLOCK_MIN_DELTA) {
                 if (printk_ratelimit())
                         printk(KERN_DEBUG "%s: small delta %lu ns\n",
                                __FUNCTION__, delta);
                 return -ETIME;
         }
+
+        /* Please wake us this far in the future. */
         hcall(LHCALL_SET_CLOCKEVENT, delta, 0, 0);
         return 0;
 }
@@ -738,7 +750,7 @@ static void lguest_time_init(void)
  * will not tolerate us trying to use that), the stack pointer, and the number
  * of pages in the stack. */
 static void lguest_load_sp0(struct tss_struct *tss,
-                                     struct thread_struct *thread)
+                            struct thread_struct *thread)
 {
         lazy_hcall(LHCALL_SET_STACK, __KERNEL_DS|0x1, thread->sp0,
                    THREAD_SIZE/PAGE_SIZE);
@@ -786,9 +798,8 @@ static void lguest_safe_halt(void)
         hcall(LHCALL_HALT, 0, 0, 0);
 }
 
-/* Perhaps CRASH isn't the best name for this hypercall, but we use it to get a
- * message out when we're crashing as well as elegant termination like powering
- * off.
+/* The SHUTDOWN hypercall takes a string to describe what's happening, and
+ * an argument which says whether this to restart (reboot) the Guest or not.
  *
  * Note that the Host always prefers that the Guest speak in physical addresses
  * rather than virtual addresses, so we use __pa() here. */
@@ -816,8 +827,9 @@ static struct notifier_block paniced = {
 /* Setting up memory is fairly easy. */
 static __init char *lguest_memory_setup(void)
 {
-        /* We do this here and not earlier because lockcheck barfs if we do it
-         * before start_kernel() */
+        /* We do this here and not earlier because lockcheck used to barf if we
+         * did it before start_kernel().  I think we fixed that, so it'd be
+         * nice to move it back to lguest_init.  Patch welcome... */
         atomic_notifier_chain_register(&panic_notifier_list, &paniced);
 
         /* The Linux bootloader header contains an "e820" memory map: the
@@ -850,12 +862,19 @@ static __init int early_put_chars(u32 vtermno, const char *buf, int count)
         return len;
 }
 
+/* Rebooting also tells the Host we're finished, but the RESTART flag tells the
+ * Launcher to reboot us. */
+static void lguest_restart(char *reason)
+{
+        hcall(LHCALL_SHUTDOWN, __pa(reason), LGUEST_SHUTDOWN_RESTART, 0);
+}
+
 /*G:050
  * Patching (Powerfully Placating Performance Pedants)
  *
- * We have already seen that pv_ops structures let us replace simple
- * native instructions with calls to the appropriate back end all throughout
- * the kernel.  This allows the same kernel to run as a Guest and as a native
+ * We have already seen that pv_ops structures let us replace simple native
+ * instructions with calls to the appropriate back end all throughout the
+ * kernel.  This allows the same kernel to run as a Guest and as a native
  * kernel, but it's slow because of all the indirect branches.
  *
  * Remember that David Wheeler quote about "Any problem in computer science can
@@ -908,14 +927,9 @@ static unsigned lguest_patch(u8 type, u16 clobber, void *ibuf,
         return insn_len;
 }
 
-static void lguest_restart(char *reason)
-{
-        hcall(LHCALL_SHUTDOWN, __pa(reason), LGUEST_SHUTDOWN_RESTART, 0);
-}
-
-/*G:030 Once we get to lguest_init(), we know we're a Guest.  The pv_ops
- * structures in the kernel provide points for (almost) every routine we have
- * to override to avoid privileged instructions. */
+/*G:030 Once we get to lguest_init(), we know we're a Guest.  The various
+ * pv_ops structures in the kernel provide points for (almost) every routine we
+ * have to override to avoid privileged instructions. */
 __init void lguest_init(void)
 {
         /* We're under lguest, paravirt is enabled, and we're running at
@@ -1003,9 +1017,9 @@ __init void lguest_init(void)
          * the normal data segment to get through booting. */
         asm volatile ("mov %0, %%fs" : : "r" (__KERNEL_DS) : "memory");
 
-        /* The Host uses the top of the Guest's virtual address space for the
-         * Host<->Guest Switcher, and it tells us how big that is in
-         * lguest_data.reserve_mem, set up on the LGUEST_INIT hypercall. */
+        /* The Host<->Guest Switcher lives at the top of our address space, and
+         * the Host told us how big it is when we made LGUEST_INIT hypercall:
+         * it put the answer in lguest_data.reserve_mem  */
         reserve_top_address(lguest_data.reserve_mem);
 
         /* If we don't initialize the lock dependency checker now, it crashes
@@ -1027,6 +1041,7 @@ __init void lguest_init(void)
         /* Math is always hard! */
         new_cpu_data.hard_math = 1;
 
+        /* We don't have features.  We have puppies!  Puppies! */
 #ifdef CONFIG_X86_MCE
         mce_disabled = 1;
 #endif
@@ -1044,10 +1059,11 @@ __init void lguest_init(void)
         virtio_cons_early_init(early_put_chars);
 
         /* Last of all, we set the power management poweroff hook to point to
-         * the Guest routine to power off. */
+         * the Guest routine to power off, and the reboot hook to our restart
+         * routine. */
         pm_power_off = lguest_power_off;
-
         machine_ops.restart = lguest_restart;
+
         /* Now we're set up, call start_kernel() in init/main.c and we proceed
          * to boot as normal.  It never returns. */
         start_kernel();
diff --git a/arch/x86/lguest/i386_head.S b/arch/x86/lguest/i386_head.S
index 95b6fbcded63..5c7cef34c9e7 100644
--- a/arch/x86/lguest/i386_head.S
+++ b/arch/x86/lguest/i386_head.S
@@ -5,13 +5,20 @@
 #include <asm/thread_info.h>
 #include <asm/processor-flags.h>
 
-/*G:020 This is where we begin: head.S notes that the boot header's platform
- * type field is "1" (lguest), so calls us here.
+/*G:020 Our story starts with the kernel booting into startup_32 in
+ * arch/x86/kernel/head_32.S.  It expects a boot header, which is created by
+ * the bootloader (the Launcher in our case).
+ *
+ * The startup_32 function does very little: it clears the uninitialized global
+ * C variables which we expect to be zero (ie. BSS) and then copies the boot
+ * header and kernel command line somewhere safe.  Finally it checks the
+ * 'hardware_subarch' field.  This was introduced in 2.6.24 for lguest and Xen:
+ * if it's set to '1' (lguest's assigned number), then it calls us here.
  *
  * WARNING: be very careful here!  We're running at addresses equal to physical
  * addesses (around 0), not above PAGE_OFFSET as most code expectes
  * (eg. 0xC0000000).  Jumps are relative, so they're OK, but we can't touch any
- * data.
+ * data without remembering to subtract __PAGE_OFFSET!
  *
  * The .section line puts this code in .init.text so it will be discarded after
  * boot. */
@@ -24,7 +31,7 @@ ENTRY(lguest_entry)
         int $LGUEST_TRAP_ENTRY
 
         /* The Host put the toplevel pagetable in lguest_data.pgdir.  The movsl
-         * instruction uses %esi implicitly as the source for the copy we'
+         * instruction uses %esi implicitly as the source for the copy we're
          * about to do. */
         movl lguest_data - __PAGE_OFFSET + LGUEST_DATA_pgdir, %esi
 
diff --git a/arch/x86/mach-rdc321x/gpio.c b/arch/x86/mach-rdc321x/gpio.c
index 031269163bd6..247f33d3a407 100644
--- a/arch/x86/mach-rdc321x/gpio.c
+++ b/arch/x86/mach-rdc321x/gpio.c
@@ -1,91 +1,194 @@
 /*
- *  Copyright (C) 2007, OpenWrt.org, Florian Fainelli <florian@openwrt.org>
- *      RDC321x architecture specific GPIO support
+ *  GPIO support for RDC SoC R3210/R8610
+ *
+ *  Copyright (C) 2007, Florian Fainelli <florian@openwrt.org>
+ *  Copyright (C) 2008, Volker Weiss <dev@tintuc.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
- *  This program is free software; you can redistribute  it and/or modify it
- *  under  the terms of  the GNU General  Public License as published by the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
  */
 
-#include <linux/autoconf.h>
-#include <linux/init.h>
+
+#include <linux/spinlock.h>
 #include <linux/io.h>
 #include <linux/types.h>
 #include <linux/module.h>
-#include <linux/delay.h>
 
+#include <asm/gpio.h>
 #include <asm/mach-rdc321x/rdc321x_defs.h>
 
-static inline int rdc_gpio_is_valid(unsigned gpio)
+
+/* spin lock to protect our private copy of GPIO data register plus
+   the access to PCI conf registers. */
+static DEFINE_SPINLOCK(gpio_lock);
+
+/* copy of GPIO data registers */
+static u32 gpio_data_reg1;
+static u32 gpio_data_reg2;
+
+static u32 gpio_request_data[2];
+
+
+static inline void rdc321x_conf_write(unsigned addr, u32 value)
 {
-        return (gpio <= RDC_MAX_GPIO);
+        outl((1 << 31) | (7 << 11) | addr, RDC3210_CFGREG_ADDR);
+        outl(value, RDC3210_CFGREG_DATA);
 }
 
-static unsigned int rdc_gpio_read(unsigned gpio)
+static inline void rdc321x_conf_or(unsigned addr, u32 value)
 {
-        unsigned int val;
-
-        val = 0x80000000 | (7 << 11) | ((gpio&0x20?0x84:0x48));
-        outl(val, RDC3210_CFGREG_ADDR);
-        udelay(10);
-        val = inl(RDC3210_CFGREG_DATA);
-        val |= (0x1 << (gpio & 0x1F));
-        outl(val, RDC3210_CFGREG_DATA);
-        udelay(10);
-        val = 0x80000000 | (7 << 11) | ((gpio&0x20?0x88:0x4C));
-        outl(val, RDC3210_CFGREG_ADDR);
-        udelay(10);
-        val = inl(RDC3210_CFGREG_DATA);
-
-        return val;
+        outl((1 << 31) | (7 << 11) | addr, RDC3210_CFGREG_ADDR);
+        value |= inl(RDC3210_CFGREG_DATA);
+        outl(value, RDC3210_CFGREG_DATA);
 }
 
-static void rdc_gpio_write(unsigned int val)
+static inline u32 rdc321x_conf_read(unsigned addr)
 {
-        if (val) {
-                outl(val, RDC3210_CFGREG_DATA);
-                udelay(10);
-        }
+        outl((1 << 31) | (7 << 11) | addr, RDC3210_CFGREG_ADDR);
+
+        return inl(RDC3210_CFGREG_DATA);
 }
 
-int rdc_gpio_get_value(unsigned gpio)
+/* configure pin as GPIO */
+static void rdc321x_configure_gpio(unsigned gpio)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&gpio_lock, flags);
+        rdc321x_conf_or(gpio < 32
+                ? RDC321X_GPIO_CTRL_REG1 : RDC321X_GPIO_CTRL_REG2,
+                1 << (gpio & 0x1f));
+        spin_unlock_irqrestore(&gpio_lock, flags);
+}
+
+/* initially setup the 2 copies of the gpio data registers.
+   This function must be called by the platform setup code. */
+void __init rdc321x_gpio_setup()
+{
+        /* this might not be, what others (BIOS, bootloader, etc.)
+           wrote to these registers before, but it's a good guess. Still
+           better than just using 0xffffffff. */
+
+        gpio_data_reg1 = rdc321x_conf_read(RDC321X_GPIO_DATA_REG1);
+        gpio_data_reg2 = rdc321x_conf_read(RDC321X_GPIO_DATA_REG2);
+}
+
+/* determine, if gpio number is valid */
+static inline int rdc321x_is_gpio(unsigned gpio)
+{
+        return gpio <= RDC321X_MAX_GPIO;
+}
+
+/* request GPIO */
+int rdc_gpio_request(unsigned gpio, const char *label)
 {
-        if (rdc_gpio_is_valid(gpio))
-                return (int)rdc_gpio_read(gpio);
-        else
+        unsigned long flags;
+
+        if (!rdc321x_is_gpio(gpio))
                 return -EINVAL;
+
+        spin_lock_irqsave(&gpio_lock, flags);
+        if (gpio_request_data[(gpio & 0x20) ? 1 : 0] & (1 << (gpio & 0x1f)))
+                goto inuse;
+        gpio_request_data[(gpio & 0x20) ? 1 : 0] |= (1 << (gpio & 0x1f));
+        spin_unlock_irqrestore(&gpio_lock, flags);
+
+        return 0;
+inuse:
+        spin_unlock_irqrestore(&gpio_lock, flags);
+        return -EINVAL;
 }
-EXPORT_SYMBOL(rdc_gpio_get_value);
+EXPORT_SYMBOL(rdc_gpio_request);
 
-void rdc_gpio_set_value(unsigned gpio, int value)
+/* release previously-claimed GPIO */
+void rdc_gpio_free(unsigned gpio)
 {
-        unsigned int val;
+        unsigned long flags;
 
-        if (!rdc_gpio_is_valid(gpio))
+        if (!rdc321x_is_gpio(gpio))
                 return;
 
-        val = rdc_gpio_read(gpio);
+        spin_lock_irqsave(&gpio_lock, flags);
+        gpio_request_data[(gpio & 0x20) ? 1 : 0] &= ~(1 << (gpio & 0x1f));
+        spin_unlock_irqrestore(&gpio_lock, flags);
+}
+EXPORT_SYMBOL(rdc_gpio_free);
+
+/* read GPIO pin */
+int rdc_gpio_get_value(unsigned gpio)
+{
+        u32 reg;
+        unsigned long flags;
+
+        spin_lock_irqsave(&gpio_lock, flags);
+        reg = rdc321x_conf_read(gpio < 32
+                ? RDC321X_GPIO_DATA_REG1 : RDC321X_GPIO_DATA_REG2);
+        spin_unlock_irqrestore(&gpio_lock, flags);
 
-        if (value)
-                val &= ~(0x1 << (gpio & 0x1F));
-        else
-                val |= (0x1 << (gpio & 0x1F));
+        return (1 << (gpio & 0x1f)) & reg ? 1 : 0;
+}
+EXPORT_SYMBOL(rdc_gpio_get_value);
 
-        rdc_gpio_write(val);
+/* set GPIO pin to value */
+void rdc_gpio_set_value(unsigned gpio, int value)
+{
+        unsigned long flags;
+        u32 reg;
+
+        reg = 1 << (gpio & 0x1f);
+        if (gpio < 32) {
+                spin_lock_irqsave(&gpio_lock, flags);
+                if (value)
+                        gpio_data_reg1 |= reg;
+                else
+                        gpio_data_reg1 &= ~reg;
+                rdc321x_conf_write(RDC321X_GPIO_DATA_REG1, gpio_data_reg1);
+                spin_unlock_irqrestore(&gpio_lock, flags);
+        } else {
+                spin_lock_irqsave(&gpio_lock, flags);
+                if (value)
+                        gpio_data_reg2 |= reg;
+                else
+                        gpio_data_reg2 &= ~reg;
+                rdc321x_conf_write(RDC321X_GPIO_DATA_REG2, gpio_data_reg2);
+                spin_unlock_irqrestore(&gpio_lock, flags);
+        }
 }
 EXPORT_SYMBOL(rdc_gpio_set_value);
 
+/* configure GPIO pin as input */
 int rdc_gpio_direction_input(unsigned gpio)
 {
+        if (!rdc321x_is_gpio(gpio))
+                return -EINVAL;
+
+        rdc321x_configure_gpio(gpio);
+
         return 0;
 }
 EXPORT_SYMBOL(rdc_gpio_direction_input);
 
+/* configure GPIO pin as output and set value */
 int rdc_gpio_direction_output(unsigned gpio, int value)
 {
+        if (!rdc321x_is_gpio(gpio))
+                return -EINVAL;
+
+        gpio_set_value(gpio, value);
+        rdc321x_configure_gpio(gpio);
+
         return 0;
 }
 EXPORT_SYMBOL(rdc_gpio_direction_output);
-
-
diff --git a/arch/x86/mach-rdc321x/platform.c b/arch/x86/mach-rdc321x/platform.c
index dda6024a5862..a037041817c7 100644
--- a/arch/x86/mach-rdc321x/platform.c
+++ b/arch/x86/mach-rdc321x/platform.c
@@ -62,6 +62,8 @@ static struct platform_device *rdc321x_devs[] = {
 
 static int __init rdc_board_setup(void)
 {
+        rdc321x_gpio_setup();
+
         return platform_add_devices(rdc321x_devs, ARRAY_SIZE(rdc321x_devs));
 }
 
diff --git a/arch/x86/mach-visws/traps.c b/arch/x86/mach-visws/traps.c
index 843b67acf43b..bfac6ba10f8a 100644
--- a/arch/x86/mach-visws/traps.c
+++ b/arch/x86/mach-visws/traps.c
@@ -46,8 +46,9 @@ static __init void cobalt_init(void)
          */
         set_fixmap(FIX_APIC_BASE, APIC_DEFAULT_PHYS_BASE);
         setup_local_APIC();
-        printk(KERN_INFO "Local APIC Version %#lx, ID %#lx\n",
-                apic_read(APIC_LVR), apic_read(APIC_ID));
+        printk(KERN_INFO "Local APIC Version %#x, ID %#x\n",
+                (unsigned int)apic_read(APIC_LVR),
+                (unsigned int)apic_read(APIC_ID));
 
         set_fixmap(FIX_CO_CPU, CO_CPU_PHYS);
         set_fixmap(FIX_CO_APIC, CO_APIC_PHYS);
diff --git a/arch/x86/mm/discontig_32.c b/arch/x86/mm/discontig_32.c
index c394ca0720b8..8e25e06ff730 100644
--- a/arch/x86/mm/discontig_32.c
+++ b/arch/x86/mm/discontig_32.c
@@ -324,7 +324,6 @@ unsigned long __init setup_memory(void)
          * this space and use it to adjust the boundary between ZONE_NORMAL
          * and ZONE_HIGHMEM.
          */
-        find_max_pfn();
         get_memcfg_numa();
 
         kva_pages = calculate_numa_remap_pages();
diff --git a/arch/x86/mm/fault.c b/arch/x86/mm/fault.c
index fdc667422df9..ec08d8389850 100644
--- a/arch/x86/mm/fault.c
+++ b/arch/x86/mm/fault.c
@@ -91,12 +91,10 @@ static int is_prefetch(struct pt_regs *regs, unsigned long addr,
         int prefetch = 0;
         unsigned char *max_instr;
 
-#ifdef CONFIG_X86_32
-        if (!(__supported_pte_mask & _PAGE_NX))
-                return 0;
-#endif
-
-        /* If it was a exec fault on NX page, ignore */
+        /*
+         * If it was a exec (instruction fetch) fault on NX page, then
+         * do not ignore the fault:
+         */
         if (error_code & PF_INSTR)
                 return 0;
 
diff --git a/arch/x86/mm/highmem_32.c b/arch/x86/mm/highmem_32.c
index 3d936f232704..9cf33d3ee5bc 100644
--- a/arch/x86/mm/highmem_32.c
+++ b/arch/x86/mm/highmem_32.c
@@ -73,15 +73,15 @@ void *kmap_atomic_prot(struct page *page, enum km_type type, pgprot_t prot)
 {
         enum fixed_addresses idx;
         unsigned long vaddr;
-        /* even !CONFIG_PREEMPT needs this, for in_atomic in do_page_fault */
-
-        debug_kmap_atomic_prot(type);
 
+        /* even !CONFIG_PREEMPT needs this, for in_atomic in do_page_fault */
         pagefault_disable();
 
         if (!PageHighMem(page))
                 return page_address(page);
 
+        debug_kmap_atomic_prot(type);
+
         idx = type + KM_TYPE_NR*smp_processor_id();
         vaddr = __fix_to_virt(FIX_KMAP_BEGIN + idx);
         BUG_ON(!pte_none(*(kmap_pte-idx)));
diff --git a/arch/x86/mm/hugetlbpage.c b/arch/x86/mm/hugetlbpage.c
index 4fbafb4bc2f0..0b3d567e686d 100644
--- a/arch/x86/mm/hugetlbpage.c
+++ b/arch/x86/mm/hugetlbpage.c
@@ -178,7 +178,7 @@ follow_huge_addr(struct mm_struct *mm, unsigned long address, int write)
 
         page = &pte_page(*pte)[vpfn % (HPAGE_SIZE/PAGE_SIZE)];
 
-        WARN_ON(!PageCompound(page));
+        WARN_ON(!PageHead(page));
 
         return page;
 }
diff --git a/arch/x86/mm/ioremap.c b/arch/x86/mm/ioremap.c
index 8fe576baa148..794895c6dcc9 100644
--- a/arch/x86/mm/ioremap.c
+++ b/arch/x86/mm/ioremap.c
@@ -106,7 +106,7 @@ static int ioremap_change_attr(unsigned long vaddr, unsigned long size,
  * have to convert them into an offset in a page-aligned mapping, but the
  * caller shouldn't need to know that small detail.
  */
-static void __iomem *__ioremap(unsigned long phys_addr, unsigned long size,
+static void __iomem *__ioremap(resource_size_t phys_addr, unsigned long size,
                                enum ioremap_mode mode)
 {
         unsigned long pfn, offset, last_addr, vaddr;
@@ -137,7 +137,11 @@ static void __iomem *__ioremap(unsigned long phys_addr, unsigned long size,
         switch (mode) {
         case IOR_MODE_UNCACHED:
         default:
-                prot = PAGE_KERNEL_NOCACHE;
+                /*
+                 * FIXME: we will use UC MINUS for now, as video fb drivers
+                 * depend on it. Upcoming ioremap_wc() will fix this behavior.
+                 */
+                prot = PAGE_KERNEL_UC_MINUS;
                 break;
         case IOR_MODE_CACHED:
                 prot = PAGE_KERNEL;
@@ -193,13 +197,13 @@ static void __iomem *__ioremap(unsigned long phys_addr, unsigned long size,
  *
  * Must be freed with iounmap.
  */
-void __iomem *ioremap_nocache(unsigned long phys_addr, unsigned long size)
+void __iomem *ioremap_nocache(resource_size_t phys_addr, unsigned long size)
 {
         return __ioremap(phys_addr, size, IOR_MODE_UNCACHED);
 }
 EXPORT_SYMBOL(ioremap_nocache);
 
-void __iomem *ioremap_cache(unsigned long phys_addr, unsigned long size)
+void __iomem *ioremap_cache(resource_size_t phys_addr, unsigned long size)
 {
         return __ioremap(phys_addr, size, IOR_MODE_CACHED);
 }
diff --git a/arch/x86/mm/numa_64.c b/arch/x86/mm/numa_64.c
index 8ccfee10f5b5..16b82ad34b96 100644
--- a/arch/x86/mm/numa_64.c
+++ b/arch/x86/mm/numa_64.c
@@ -221,8 +221,7 @@ void __init setup_node_bootmem(int nodeid, unsigned long start,
                                  bootmap_pages<<PAGE_SHIFT, PAGE_SIZE);
         if (bootmap == NULL)  {
                 if (nodedata_phys < start || nodedata_phys >= end)
-                        free_bootmem((unsigned long)node_data[nodeid],
-                                     pgdat_size);
+                        free_bootmem(nodedata_phys, pgdat_size);
                 node_data[nodeid] = NULL;
                 return;
         }
diff --git a/arch/x86/mm/pageattr.c b/arch/x86/mm/pageattr.c
index 14e48b5a94ba..7b79f6be4e7d 100644
--- a/arch/x86/mm/pageattr.c
+++ b/arch/x86/mm/pageattr.c
@@ -771,7 +771,7 @@ static inline int change_page_attr_clear(unsigned long addr, int numpages,
 int set_memory_uc(unsigned long addr, int numpages)
 {
         return change_page_attr_set(addr, numpages,
-                                    __pgprot(_PAGE_PCD | _PAGE_PWT));
+                                    __pgprot(_PAGE_PCD));
 }
 EXPORT_SYMBOL(set_memory_uc);
 
diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c
index 8b9ee27805fd..de4e6f05840b 100644
--- a/arch/x86/xen/enlighten.c
+++ b/arch/x86/xen/enlighten.c
@@ -95,7 +95,7 @@ struct shared_info *HYPERVISOR_shared_info = (void *)&dummy_shared_info;
  *
  * 0: not available, 1: available
  */
-static int have_vcpu_info_placement = 0;
+static int have_vcpu_info_placement = 1;
 
 static void __init xen_vcpu_setup(int cpu)
 {
@@ -103,6 +103,7 @@ static void __init xen_vcpu_setup(int cpu)
         int err;
         struct vcpu_info *vcpup;
 
+        BUG_ON(HYPERVISOR_shared_info == &dummy_shared_info);
         per_cpu(xen_vcpu, cpu) = &HYPERVISOR_shared_info->vcpu_info[cpu];
 
         if (!have_vcpu_info_placement)
@@ -805,33 +806,43 @@ static __init void xen_pagetable_setup_start(pgd_t *base)
                           PFN_DOWN(__pa(xen_start_info->pt_base)));
 }
 
-static __init void xen_pagetable_setup_done(pgd_t *base)
+static __init void setup_shared_info(void)
 {
-        /* This will work as long as patching hasn't happened yet
-           (which it hasn't) */
-        pv_mmu_ops.alloc_pt = xen_alloc_pt;
-        pv_mmu_ops.alloc_pd = xen_alloc_pd;
-        pv_mmu_ops.release_pt = xen_release_pt;
-        pv_mmu_ops.release_pd = xen_release_pt;
-        pv_mmu_ops.set_pte = xen_set_pte;
-
         if (!xen_feature(XENFEAT_auto_translated_physmap)) {
+                unsigned long addr = fix_to_virt(FIX_PARAVIRT_BOOTMAP);
+
                 /*
                  * Create a mapping for the shared info page.
                  * Should be set_fixmap(), but shared_info is a machine
                  * address with no corresponding pseudo-phys address.
                  */
-                set_pte_mfn(fix_to_virt(FIX_PARAVIRT_BOOTMAP),
+                set_pte_mfn(addr,
                             PFN_DOWN(xen_start_info->shared_info),
                             PAGE_KERNEL);
 
-                HYPERVISOR_shared_info =
-                        (struct shared_info *)fix_to_virt(FIX_PARAVIRT_BOOTMAP);
-
+                HYPERVISOR_shared_info = (struct shared_info *)addr;
         } else
                 HYPERVISOR_shared_info =
                         (struct shared_info *)__va(xen_start_info->shared_info);
 
+#ifndef CONFIG_SMP
+        /* In UP this is as good a place as any to set up shared info */
+        xen_setup_vcpu_info_placement();
+#endif
+}
+
+static __init void xen_pagetable_setup_done(pgd_t *base)
+{
+        /* This will work as long as patching hasn't happened yet
+           (which it hasn't) */
+        pv_mmu_ops.alloc_pt = xen_alloc_pt;
+        pv_mmu_ops.alloc_pd = xen_alloc_pd;
+        pv_mmu_ops.release_pt = xen_release_pt;
+        pv_mmu_ops.release_pd = xen_release_pt;
+        pv_mmu_ops.set_pte = xen_set_pte;
+
+        setup_shared_info();
+
         /* Actually pin the pagetable down, but we can't set PG_pinned
            yet because the page structures don't exist yet. */
         {
@@ -1182,15 +1193,9 @@ asmlinkage void __init xen_start_kernel(void)
         x86_write_percpu(xen_cr3, __pa(pgd));
         x86_write_percpu(xen_current_cr3, __pa(pgd));
 
-#ifdef CONFIG_SMP
         /* Don't do the full vcpu_info placement stuff until we have a
-           possible map. */
+           possible map and a non-dummy shared_info. */
         per_cpu(xen_vcpu, 0) = &HYPERVISOR_shared_info->vcpu_info[0];
-#else
-        /* May as well do it now, since there's no good time to call
-           it later on UP. */
-        xen_setup_vcpu_info_placement();
-#endif
 
         pv_info.kernel_rpl = 1;
         if (xen_feature(XENFEAT_supervisor_mode_kernel))
diff --git a/arch/x86/xen/xen-asm.S b/arch/x86/xen/xen-asm.S
index 1a43b60c0c62..6b7190449d07 100644
--- a/arch/x86/xen/xen-asm.S
+++ b/arch/x86/xen/xen-asm.S
@@ -33,12 +33,17 @@
         events, then enter the hypervisor to get them handled.
  */
 ENTRY(xen_irq_enable_direct)
-        /* Clear mask and test pending */
-        andw $0x00ff, PER_CPU_VAR(xen_vcpu_info)+XEN_vcpu_info_pending
+        /* Unmask events */
+        movb $0, PER_CPU_VAR(xen_vcpu_info)+XEN_vcpu_info_mask
+
         /* Preempt here doesn't matter because that will deal with
            any pending interrupts.  The pending check may end up being
            run on the wrong CPU, but that doesn't hurt. */
+
+        /* Test for pending */
+        testb $0xff, PER_CPU_VAR(xen_vcpu_info)+XEN_vcpu_info_pending
         jz 1f
+
 2:      call check_events
 1:
 ENDPATCH(xen_irq_enable_direct)