9 files changed, 131 insertions, 122 deletions

diff --git a/arch/arm/mach-rpc/riscpc.c b/arch/arm/mach-rpc/riscpc.c
index e88d417736a..c7fc01e9d1f 100644
--- a/arch/arm/mach-rpc/riscpc.c
+++ b/arch/arm/mach-rpc/riscpc.c
@@ -19,6 +19,7 @@
 #include <linux/serial_8250.h>
 #include <linux/ata_platform.h>
 #include <linux/io.h>
+#include <linux/i2c.h>
 
 #include <asm/elf.h>
 #include <asm/mach-types.h>
@@ -201,8 +202,13 @@ static struct platform_device *devs[] __initdata = {
         &pata_device,
 };
 
+static struct i2c_board_info i2c_rtc = {
+        I2C_BOARD_INFO("pcf8583", 0x50)
+};
+
 static int __init rpc_init(void)
 {
+        i2c_register_board_info(0, &i2c_rtc, 1);
         return platform_add_devices(devs, ARRAY_SIZE(devs));
 }
 
diff --git a/arch/x86/configs/i386_defconfig b/arch/x86/configs/i386_defconfig
index 5c023f6f652..235b81d0f6f 100644
--- a/arch/x86/configs/i386_defconfig
+++ b/arch/x86/configs/i386_defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
 # Linux kernel version: 2.6.29-rc4
-# Thu Feb 12 12:57:57 2009
+# Tue Feb 24 15:50:58 2009
 #
 # CONFIG_64BIT is not set
 CONFIG_X86_32=y
@@ -266,7 +266,9 @@ CONFIG_PREEMPT_VOLUNTARY=y
 CONFIG_X86_LOCAL_APIC=y
 CONFIG_X86_IO_APIC=y
 CONFIG_X86_REROUTE_FOR_BROKEN_BOOT_IRQS=y
-# CONFIG_X86_MCE is not set
+CONFIG_X86_MCE=y
+CONFIG_X86_MCE_NONFATAL=y
+CONFIG_X86_MCE_P4THERMAL=y
 CONFIG_VM86=y
 # CONFIG_TOSHIBA is not set
 # CONFIG_I8K is not set
diff --git a/arch/x86/configs/x86_64_defconfig b/arch/x86/configs/x86_64_defconfig
index 4157cc4a2bd..9fe5d212ab4 100644
--- a/arch/x86/configs/x86_64_defconfig
+++ b/arch/x86/configs/x86_64_defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
 # Linux kernel version: 2.6.29-rc4
-# Thu Feb 12 12:57:29 2009
+# Tue Feb 24 15:44:16 2009
 #
 CONFIG_64BIT=y
 # CONFIG_X86_32 is not set
@@ -266,7 +266,9 @@ CONFIG_PREEMPT_VOLUNTARY=y
 CONFIG_X86_LOCAL_APIC=y
 CONFIG_X86_IO_APIC=y
 CONFIG_X86_REROUTE_FOR_BROKEN_BOOT_IRQS=y
-# CONFIG_X86_MCE is not set
+CONFIG_X86_MCE=y
+CONFIG_X86_MCE_INTEL=y
+CONFIG_X86_MCE_AMD=y
 # CONFIG_I8K is not set
 CONFIG_MICROCODE=y
 CONFIG_MICROCODE_INTEL=y
diff --git a/arch/x86/include/asm/uaccess_32.h b/arch/x86/include/asm/uaccess_32.h
index 5e06259e90e..a0ba6138697 100644
--- a/arch/x86/include/asm/uaccess_32.h
+++ b/arch/x86/include/asm/uaccess_32.h
@@ -157,7 +157,7 @@ __copy_from_user(void *to, const void __user *from, unsigned long n)
 }
 
 static __always_inline unsigned long __copy_from_user_nocache(void *to,
-                                const void __user *from, unsigned long n)
+                const void __user *from, unsigned long n, unsigned long total)
 {
         might_fault();
         if (__builtin_constant_p(n)) {
@@ -180,7 +180,7 @@ static __always_inline unsigned long __copy_from_user_nocache(void *to,
 
 static __always_inline unsigned long
 __copy_from_user_inatomic_nocache(void *to, const void __user *from,
-                                  unsigned long n)
+                                  unsigned long n, unsigned long total)
 {
        return __copy_from_user_ll_nocache_nozero(to, from, n);
 }
diff --git a/arch/x86/include/asm/uaccess_64.h b/arch/x86/include/asm/uaccess_64.h
index 987a2c10fe2..dcaa0404cf7 100644
--- a/arch/x86/include/asm/uaccess_64.h
+++ b/arch/x86/include/asm/uaccess_64.h
@@ -189,7 +189,7 @@ extern long __copy_user_nocache(void *dst, const void __user *src,
                                 unsigned size, int zerorest);
 
 static inline int __copy_from_user_nocache(void *dst, const void __user *src,
-                                           unsigned size)
+                                   unsigned size, unsigned long total)
 {
         might_sleep();
         /*
@@ -198,17 +198,16 @@ static inline int __copy_from_user_nocache(void *dst, const void __user *src,
          * non-temporal stores here. Smaller writes get handled
          * via regular __copy_from_user():
          */
-        if (likely(size >= PAGE_SIZE))
+        if (likely(total >= PAGE_SIZE))
                 return __copy_user_nocache(dst, src, size, 1);
         else
                 return __copy_from_user(dst, src, size);
 }
 
 static inline int __copy_from_user_inatomic_nocache(void *dst,
-                                                    const void __user *src,
-                                                    unsigned size)
+            const void __user *src, unsigned size, unsigned total)
 {
-        if (likely(size >= PAGE_SIZE))
+        if (likely(total >= PAGE_SIZE))
                 return __copy_user_nocache(dst, src, size, 0);
         else
                 return __copy_from_user_inatomic(dst, src, size);
diff --git a/arch/x86/kernel/alternative.c b/arch/x86/kernel/alternative.c
index a84ac7b570e..6907b8e85d5 100644
--- a/arch/x86/kernel/alternative.c
+++ b/arch/x86/kernel/alternative.c
@@ -498,12 +498,12 @@ void *text_poke_early(void *addr, const void *opcode, size_t len)
  */
 void *__kprobes text_poke(void *addr, const void *opcode, size_t len)
 {
-        unsigned long flags;
         char *vaddr;
         int nr_pages = 2;
         struct page *pages[2];
         int i;
 
+        might_sleep();
         if (!core_kernel_text((unsigned long)addr)) {
                 pages[0] = vmalloc_to_page(addr);
                 pages[1] = vmalloc_to_page(addr + PAGE_SIZE);
@@ -517,9 +517,9 @@ void *__kprobes text_poke(void *addr, const void *opcode, size_t len)
                 nr_pages = 1;
         vaddr = vmap(pages, nr_pages, VM_MAP, PAGE_KERNEL);
         BUG_ON(!vaddr);
-        local_irq_save(flags);
+        local_irq_disable();
         memcpy(&vaddr[(unsigned long)addr & ~PAGE_MASK], opcode, len);
-        local_irq_restore(flags);
+        local_irq_enable();
         vunmap(vaddr);
         sync_core();
         /* Could also do a CLFLUSH here to speed up CPU recovery; but
diff --git a/arch/x86/kernel/apic/summit_32.c b/arch/x86/kernel/apic/summit_32.c
index cfe7b09015d..32838b57a94 100644
--- a/arch/x86/kernel/apic/summit_32.c
+++ b/arch/x86/kernel/apic/summit_32.c
@@ -48,7 +48,7 @@
 #include <linux/gfp.h>
 #include <linux/smp.h>
 
-static inline unsigned summit_get_apic_id(unsigned long x)
+static unsigned summit_get_apic_id(unsigned long x)
 {
         return (x >> 24) & 0xFF;
 }
@@ -58,7 +58,7 @@ static inline void summit_send_IPI_mask(const cpumask_t *mask, int vector)
         default_send_IPI_mask_sequence_logical(mask, vector);
 }
 
-static inline void summit_send_IPI_allbutself(int vector)
+static void summit_send_IPI_allbutself(int vector)
 {
         cpumask_t mask = cpu_online_map;
         cpu_clear(smp_processor_id(), mask);
@@ -67,7 +67,7 @@ static inline void summit_send_IPI_allbutself(int vector)
                 summit_send_IPI_mask(&mask, vector);
 }
 
-static inline void summit_send_IPI_all(int vector)
+static void summit_send_IPI_all(int vector)
 {
         summit_send_IPI_mask(&cpu_online_map, vector);
 }
@@ -82,8 +82,8 @@ extern void setup_summit(void);
 #define setup_summit()  {}
 #endif
 
-static inline int
-summit_mps_oem_check(struct mpc_table *mpc, char *oem, char *productid)
+static int summit_mps_oem_check(struct mpc_table *mpc, char *oem,
+                char *productid)
 {
         if (!strncmp(oem, "IBM ENSW", 8) &&
                         (!strncmp(productid, "VIGIL SMP", 9)
@@ -98,7 +98,7 @@ summit_mps_oem_check(struct mpc_table *mpc, char *oem, char *productid)
 }
 
 /* Hook from generic ACPI tables.c */
-static inline int summit_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
+static int summit_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
 {
         if (!strncmp(oem_id, "IBM", 3) &&
             (!strncmp(oem_table_id, "SERVIGIL", 8)
@@ -186,7 +186,7 @@ static inline int is_WPEG(struct rio_detail *rio){
 
 #define SUMMIT_APIC_DFR_VALUE   (APIC_DFR_CLUSTER)
 
-static inline const cpumask_t *summit_target_cpus(void)
+static const cpumask_t *summit_target_cpus(void)
 {
         /* CPU_MASK_ALL (0xff) has undefined behaviour with
          * dest_LowestPrio mode logical clustered apic interrupt routing
@@ -195,19 +195,18 @@ static inline const cpumask_t *summit_target_cpus(void)
         return &cpumask_of_cpu(0);
 }
 
-static inline unsigned long
-summit_check_apicid_used(physid_mask_t bitmap, int apicid)
+static unsigned long summit_check_apicid_used(physid_mask_t bitmap, int apicid)
 {
         return 0;
 }
 
 /* we don't use the phys_cpu_present_map to indicate apicid presence */
-static inline unsigned long summit_check_apicid_present(int bit)
+static unsigned long summit_check_apicid_present(int bit)
 {
         return 1;
 }
 
-static inline void summit_init_apic_ldr(void)
+static void summit_init_apic_ldr(void)
 {
         unsigned long val, id;
         int count = 0;
@@ -234,18 +233,18 @@ static inline void summit_init_apic_ldr(void)
         apic_write(APIC_LDR, val);
 }
 
-static inline int summit_apic_id_registered(void)
+static int summit_apic_id_registered(void)
 {
         return 1;
 }
 
-static inline void summit_setup_apic_routing(void)
+static void summit_setup_apic_routing(void)
 {
         printk("Enabling APIC mode:  Summit.  Using %d I/O APICs\n",
                                                 nr_ioapics);
 }
 
-static inline int summit_apicid_to_node(int logical_apicid)
+static int summit_apicid_to_node(int logical_apicid)
 {
 #ifdef CONFIG_SMP
         return apicid_2_node[hard_smp_processor_id()];
@@ -266,7 +265,7 @@ static inline int summit_cpu_to_logical_apicid(int cpu)
 #endif
 }
 
-static inline int summit_cpu_present_to_apicid(int mps_cpu)
+static int summit_cpu_present_to_apicid(int mps_cpu)
 {
         if (mps_cpu < nr_cpu_ids)
                 return (int)per_cpu(x86_bios_cpu_apicid, mps_cpu);
@@ -274,28 +273,23 @@ static inline int summit_cpu_present_to_apicid(int mps_cpu)
                 return BAD_APICID;
 }
 
-static inline physid_mask_t
-summit_ioapic_phys_id_map(physid_mask_t phys_id_map)
+static physid_mask_t summit_ioapic_phys_id_map(physid_mask_t phys_id_map)
 {
         /* For clustered we don't have a good way to do this yet - hack */
         return physids_promote(0x0F);
 }
 
-static inline physid_mask_t summit_apicid_to_cpu_present(int apicid)
+static physid_mask_t summit_apicid_to_cpu_present(int apicid)
 {
         return physid_mask_of_physid(0);
 }
 
-static inline void summit_setup_portio_remap(void)
-{
-}
-
-static inline int summit_check_phys_apicid_present(int boot_cpu_physical_apicid)
+static int summit_check_phys_apicid_present(int boot_cpu_physical_apicid)
 {
         return 1;
 }
 
-static inline unsigned int summit_cpu_mask_to_apicid(const cpumask_t *cpumask)
+static unsigned int summit_cpu_mask_to_apicid(const cpumask_t *cpumask)
 {
         int cpus_found = 0;
         int num_bits_set;
@@ -303,12 +297,10 @@ static inline unsigned int summit_cpu_mask_to_apicid(const cpumask_t *cpumask)
         int cpu;
 
         num_bits_set = cpus_weight(*cpumask);
-        /* Return id to all */
         if (num_bits_set >= nr_cpu_ids)
-                return 0xFF;
+                return BAD_APICID;
         /*
-         * The cpus in the mask must all be on the apic cluster.  If are not
-         * on the same apicid cluster return default value of target_cpus():
+         * The cpus in the mask must all be on the apic cluster.
          */
         cpu = first_cpu(*cpumask);
         apicid = summit_cpu_to_logical_apicid(cpu);
@@ -318,9 +310,9 @@ static inline unsigned int summit_cpu_mask_to_apicid(const cpumask_t *cpumask)
                         int new_apicid = summit_cpu_to_logical_apicid(cpu);
 
                         if (APIC_CLUSTER(apicid) != APIC_CLUSTER(new_apicid)) {
-                                printk ("%s: Not a valid mask!\n", __func__);
+                                printk("%s: Not a valid mask!\n", __func__);
 
-                                return 0xFF;
+                                return BAD_APICID;
                         }
                         apicid = apicid | new_apicid;
                         cpus_found++;
@@ -330,8 +322,7 @@ static inline unsigned int summit_cpu_mask_to_apicid(const cpumask_t *cpumask)
         return apicid;
 }
 
-static inline unsigned int
-summit_cpu_mask_to_apicid_and(const struct cpumask *inmask,
+static unsigned int summit_cpu_mask_to_apicid_and(const struct cpumask *inmask,
                               const struct cpumask *andmask)
 {
         int apicid = summit_cpu_to_logical_apicid(0);
@@ -356,7 +347,7 @@ summit_cpu_mask_to_apicid_and(const struct cpumask *inmask,
  *
  * See Intel's IA-32 SW Dev's Manual Vol2 under CPUID.
  */
-static inline int summit_phys_pkg_id(int cpuid_apic, int index_msb)
+static int summit_phys_pkg_id(int cpuid_apic, int index_msb)
 {
         return hard_smp_processor_id() >> index_msb;
 }
diff --git a/arch/x86/kernel/e820.c b/arch/x86/kernel/e820.c
index e85826829cf..508bec1cee2 100644
--- a/arch/x86/kernel/e820.c
+++ b/arch/x86/kernel/e820.c
@@ -858,6 +858,9 @@ void __init reserve_early_overlap_ok(u64 start, u64 end, char *name)
  */
 void __init reserve_early(u64 start, u64 end, char *name)
 {
+        if (start >= end)
+                return;
+
         drop_overlaps_that_are_ok(start, end);
         __reserve_early(start, end, name, 0);
 }
diff --git a/arch/x86/mm/memtest.c b/arch/x86/mm/memtest.c
index 9cab18b0b85..0bcd7883d03 100644
--- a/arch/x86/mm/memtest.c
+++ b/arch/x86/mm/memtest.c
@@ -9,44 +9,44 @@
 
 #include <asm/e820.h>
 
-static void __init memtest(unsigned long start_phys, unsigned long size,
-                                 unsigned pattern)
+static u64 patterns[] __initdata = {
+        0,
+        0xffffffffffffffffULL,
+        0x5555555555555555ULL,
+        0xaaaaaaaaaaaaaaaaULL,
+        0x1111111111111111ULL,
+        0x2222222222222222ULL,
+        0x4444444444444444ULL,
+        0x8888888888888888ULL,
+        0x3333333333333333ULL,
+        0x6666666666666666ULL,
+        0x9999999999999999ULL,
+        0xccccccccccccccccULL,
+        0x7777777777777777ULL,
+        0xbbbbbbbbbbbbbbbbULL,
+        0xddddddddddddddddULL,
+        0xeeeeeeeeeeeeeeeeULL,
+        0x7a6c7258554e494cULL, /* yeah ;-) */
+};
+
+static void __init reserve_bad_mem(u64 pattern, u64 start_bad, u64 end_bad)
 {
-        unsigned long i;
-        unsigned long *start;
-        unsigned long start_bad;
-        unsigned long last_bad;
-        unsigned long val;
-        unsigned long start_phys_aligned;
-        unsigned long count;
-        unsigned long incr;
-
-        switch (pattern) {
-        case 0:
-                val = 0UL;
-                break;
-        case 1:
-                val = -1UL;
-                break;
-        case 2:
-#ifdef CONFIG_X86_64
-                val = 0x5555555555555555UL;
-#else
-                val = 0x55555555UL;
-#endif
-                break;
-        case 3:
-#ifdef CONFIG_X86_64
-                val = 0xaaaaaaaaaaaaaaaaUL;
-#else
-                val = 0xaaaaaaaaUL;
-#endif
-                break;
-        default:
-                return;
-        }
+        printk(KERN_INFO "  %016llx bad mem addr %010llx - %010llx reserved\n",
+               (unsigned long long) pattern,
+               (unsigned long long) start_bad,
+               (unsigned long long) end_bad);
+        reserve_early(start_bad, end_bad, "BAD RAM");
+}
 
-        incr = sizeof(unsigned long);
+static void __init memtest(u64 pattern, u64 start_phys, u64 size)
+{
+        u64 i, count;
+        u64 *start;
+        u64 start_bad, last_bad;
+        u64 start_phys_aligned;
+        size_t incr;
+
+        incr = sizeof(pattern);
         start_phys_aligned = ALIGN(start_phys, incr);
         count = (size - (start_phys_aligned - start_phys))/incr;
         start = __va(start_phys_aligned);
@@ -54,25 +54,42 @@ static void __init memtest(unsigned long start_phys, unsigned long size,
         last_bad = 0;
 
         for (i = 0; i < count; i++)
-                start[i] = val;
+                start[i] = pattern;
         for (i = 0; i < count; i++, start++, start_phys_aligned += incr) {
-                if (*start != val) {
-                        if (start_phys_aligned == last_bad + incr) {
-                                last_bad += incr;
-                        } else {
-                                if (start_bad) {
-                                        printk(KERN_CONT "\n  %016lx bad mem addr %010lx - %010lx reserved",
-                                                val, start_bad, last_bad + incr);
-                                        reserve_early(start_bad, last_bad + incr, "BAD RAM");
-                                }
-                                start_bad = last_bad = start_phys_aligned;
-                        }
+                if (*start == pattern)
+                        continue;
+                if (start_phys_aligned == last_bad + incr) {
+                        last_bad += incr;
+                        continue;
                 }
+                if (start_bad)
+                        reserve_bad_mem(pattern, start_bad, last_bad + incr);
+                start_bad = last_bad = start_phys_aligned;
         }
-        if (start_bad) {
-                printk(KERN_CONT "\n  %016lx bad mem addr %010lx - %010lx reserved",
-                        val, start_bad, last_bad + incr);
-                reserve_early(start_bad, last_bad + incr, "BAD RAM");
+        if (start_bad)
+                reserve_bad_mem(pattern, start_bad, last_bad + incr);
+}
+
+static void __init do_one_pass(u64 pattern, u64 start, u64 end)
+{
+        u64 size = 0;
+
+        while (start < end) {
+                start = find_e820_area_size(start, &size, 1);
+
+                /* done ? */
+                if (start >= end)
+                        break;
+                if (start + size > end)
+                        size = end - start;
+
+                printk(KERN_INFO "  %010llx - %010llx pattern %016llx\n",
+                       (unsigned long long) start,
+                       (unsigned long long) start + size,
+                       (unsigned long long) cpu_to_be64(pattern));
+                memtest(pattern, start, size);
+
+                start += size;
         }
 }
 
@@ -90,33 +107,22 @@ early_param("memtest", parse_memtest);
 
 void __init early_memtest(unsigned long start, unsigned long end)
 {
-        u64 t_start, t_size;
-        unsigned pattern;
+        unsigned int i;
+        unsigned int idx = 0;
 
         if (!memtest_pattern)
                 return;
 
-        printk(KERN_INFO "early_memtest: pattern num %d", memtest_pattern);
-        for (pattern = 0; pattern < memtest_pattern; pattern++) {
-                t_start = start;
-                t_size = 0;
-                while (t_start < end) {
-                        t_start = find_e820_area_size(t_start, &t_size, 1);
-
-                        /* done ? */
-                        if (t_start >= end)
-                                break;
-                        if (t_start + t_size > end)
-                                t_size = end - t_start;
-
-                        printk(KERN_CONT "\n  %010llx - %010llx pattern %d",
-                                (unsigned long long)t_start,
-                                (unsigned long long)t_start + t_size, pattern);
-
-                        memtest(t_start, t_size, pattern);
+        printk(KERN_INFO "early_memtest: # of tests: %d\n", memtest_pattern);
+        for (i = 0; i < memtest_pattern; i++) {
+                idx = i % ARRAY_SIZE(patterns);
+                do_one_pass(patterns[idx], start, end);
+        }
 
-                        t_start += t_size;
-                }
+        if (idx > 0) {
+                printk(KERN_INFO "early_memtest: wipe out "
+                       "test pattern from memory\n");
+                /* additional test with pattern 0 will do this */
+                do_one_pass(0, start, end);
         }
-        printk(KERN_CONT "\n");
 }