9 files changed, 213 insertions, 70 deletions

diff --git a/arch/x86/kernel/acpi/boot.c b/arch/x86/kernel/acpi/boot.c
index 5c0107602b62..bf7b4f7f60e1 100644
--- a/arch/x86/kernel/acpi/boot.c
+++ b/arch/x86/kernel/acpi/boot.c
@@ -37,6 +37,7 @@
 #include <asm/pgtable.h>
 #include <asm/io_apic.h>
 #include <asm/apic.h>
+#include <asm/genapic.h>
 #include <asm/io.h>
 #include <asm/mpspec.h>
 #include <asm/smp.h>
@@ -1373,8 +1374,6 @@ static void __init acpi_process_madt(void)
         return;
 }
 
-#ifdef __i386__
-
 static int __init disable_acpi_irq(const struct dmi_system_id *d)
 {
         if (!acpi_force) {
@@ -1436,6 +1435,17 @@ dmi_disable_irq0_through_ioapic(const struct dmi_system_id *d)
 }
 
 /*
+ * Force ignoring BIOS IRQ0 pin2 override
+ */
+static int __init dmi_ignore_irq0_timer_override(const struct dmi_system_id *d)
+{
+        pr_notice("%s detected: Ignoring BIOS IRQ0 pin2 override\n", d->ident);
+        acpi_skip_timer_override = 1;
+        force_mask_ioapic_irq_2();
+        return 0;
+}
+
+/*
  * If your system is blacklisted here, but you find that acpi=force
  * works for you, please contact acpi-devel@sourceforge.net
  */
@@ -1628,11 +1638,35 @@ static struct dmi_system_id __initdata acpi_dmi_table[] = {
                      DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6325"),
                      },
          },
+        /*
+         * HP laptops which use a DSDT reporting as HP/SB400/10000,
+         * which includes some code which overrides all temperature
+         * trip points to 16C if the INTIN2 input of the I/O APIC
+         * is enabled.  This input is incorrectly designated the
+         * ISA IRQ 0 via an interrupt source override even though
+         * it is wired to the output of the master 8259A and INTIN0
+         * is not connected at all.  Force ignoring BIOS IRQ0 pin2
+         * override in that cases.
+         */
+        {
+         .callback = dmi_ignore_irq0_timer_override,
+         .ident = "HP NX6125 laptop",
+         .matches = {
+                     DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
+                     DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6125"),
+                     },
+         },
+        {
+         .callback = dmi_ignore_irq0_timer_override,
+         .ident = "HP NX6325 laptop",
+         .matches = {
+                     DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
+                     DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6325"),
+                     },
+         },
         {}
 };
 
-#endif                          /* __i386__ */
-
 /*
  * acpi_boot_table_init() and acpi_boot_init()
  *  called from setup_arch(), always.
@@ -1660,9 +1694,7 @@ int __init acpi_boot_table_init(void)
 {
         int error;
 
-#ifdef __i386__
         dmi_check_system(acpi_dmi_table);
-#endif
 
         /*
          * If acpi_disabled, bail out
diff --git a/arch/x86/kernel/e820.c b/arch/x86/kernel/e820.c
index e07d4019e266..66fd5bd78318 100644
--- a/arch/x86/kernel/e820.c
+++ b/arch/x86/kernel/e820.c
@@ -1056,12 +1056,25 @@ unsigned long __initdata end_user_pfn = MAX_ARCH_PFN;
 /*
  * Find the highest page frame number we have available
  */
-unsigned long __init e820_end_of_ram(void)
+unsigned long __init e820_end(void)
 {
-        unsigned long last_pfn;
+        int i;
+        unsigned long last_pfn = 0;
         unsigned long max_arch_pfn = MAX_ARCH_PFN;
 
-        last_pfn = find_max_pfn_with_active_regions();
+        for (i = 0; i < e820.nr_map; i++) {
+                struct e820entry *ei = &e820.map[i];
+                unsigned long end_pfn;
+
+#ifdef CONFIG_X86_32
+                if (ei->type != E820_RAM)
+                        continue;
+#endif
+
+                end_pfn = (ei->addr + ei->size) >> PAGE_SHIFT;
+                if (end_pfn > last_pfn)
+                        last_pfn = end_pfn;
+        }
 
         if (last_pfn > max_arch_pfn)
                 last_pfn = max_arch_pfn;
@@ -1185,6 +1198,9 @@ static int __init parse_memmap_opt(char *p)
         char *oldp;
         u64 start_at, mem_size;
 
+        if (!p)
+                return -EINVAL;
+
         if (!strcmp(p, "exactmap")) {
 #ifdef CONFIG_CRASH_DUMP
                 /*
@@ -1192,9 +1208,7 @@ static int __init parse_memmap_opt(char *p)
                  * the real mem size before original memory map is
                  * reset.
                  */
-                e820_register_active_regions(0, 0, -1UL);
-                saved_max_pfn = e820_end_of_ram();
-                remove_all_active_ranges();
+                saved_max_pfn = e820_end();
 #endif
                 e820.nr_map = 0;
                 userdef = 1;
diff --git a/arch/x86/kernel/io_apic_32.c b/arch/x86/kernel/io_apic_32.c
index 337ec3438a8f..6b220b9dcbb3 100644
--- a/arch/x86/kernel/io_apic_32.c
+++ b/arch/x86/kernel/io_apic_32.c
@@ -59,6 +59,13 @@ static struct { int pin, apic; } ioapic_i8259 = { -1, -1 };
 static DEFINE_SPINLOCK(ioapic_lock);
 static DEFINE_SPINLOCK(vector_lock);
 
+static bool mask_ioapic_irq_2 __initdata;
+
+void __init force_mask_ioapic_irq_2(void)
+{
+        mask_ioapic_irq_2 = true;
+}
+
 int timer_through_8259 __initdata;
 
 /*
@@ -2172,6 +2179,9 @@ static inline void __init check_timer(void)
         printk(KERN_INFO "..TIMER: vector=0x%02X apic1=%d pin1=%d apic2=%d pin2=%d\n",
                 vector, apic1, pin1, apic2, pin2);
 
+        if (mask_ioapic_irq_2)
+                mask_IO_APIC_irq(2);
+
         /*
          * Some BIOS writers are clueless and report the ExtINTA
          * I/O APIC input from the cascaded 8259A as the timer
diff --git a/arch/x86/kernel/io_apic_64.c b/arch/x86/kernel/io_apic_64.c
index 2b4c40bc12c9..0494cdb270c5 100644
--- a/arch/x86/kernel/io_apic_64.c
+++ b/arch/x86/kernel/io_apic_64.c
@@ -94,6 +94,13 @@ static int no_timer_check;
 
 static int disable_timer_pin_1 __initdata;
 
+static bool mask_ioapic_irq_2 __initdata;
+
+void __init force_mask_ioapic_irq_2(void)
+{
+        mask_ioapic_irq_2 = true;
+}
+
 int timer_through_8259 __initdata;
 
 /* Where if anywhere is the i8259 connect in external int mode */
@@ -1698,6 +1705,9 @@ static inline void __init check_timer(void)
         apic_printk(APIC_VERBOSE,KERN_INFO "..TIMER: vector=0x%02X apic1=%d pin1=%d apic2=%d pin2=%d\n",
                 cfg->vector, apic1, pin1, apic2, pin2);
 
+        if (mask_ioapic_irq_2)
+                mask_IO_APIC_irq(2);
+
         /*
          * Some BIOS writers are clueless and report the ExtINTA
          * I/O APIC input from the cascaded 8259A as the timer
diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c
index bea8ae77d059..a7c3471ea17c 100644
--- a/arch/x86/kernel/setup.c
+++ b/arch/x86/kernel/setup.c
@@ -709,22 +709,18 @@ void __init setup_arch(char **cmdline_p)
         early_gart_iommu_check();
 #endif
 
-        e820_register_active_regions(0, 0, -1UL);
         /*
          * partially used pages are not usable - thus
          * we are rounding upwards:
          */
-        max_pfn = e820_end_of_ram();
+        max_pfn = e820_end();
 
         /* preallocate 4k for mptable mpc */
         early_reserve_e820_mpc_new();
         /* update e820 for memory not covered by WB MTRRs */
         mtrr_bp_init();
-        if (mtrr_trim_uncached_memory(max_pfn)) {
-                remove_all_active_ranges();
-                e820_register_active_regions(0, 0, -1UL);
-                max_pfn = e820_end_of_ram();
-        }
+        if (mtrr_trim_uncached_memory(max_pfn))
+                max_pfn = e820_end();
 
 #ifdef CONFIG_X86_32
         /* max_low_pfn get updated here */
@@ -767,9 +763,6 @@ void __init setup_arch(char **cmdline_p)
          */
         acpi_boot_table_init();
 
-        /* Remove active ranges so rediscovery with NUMA-awareness happens */
-        remove_all_active_ranges();
-
 #ifdef CONFIG_ACPI_NUMA
         /*
          * Parse SRAT to discover nodes.
diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c
index 57d5eff754c9..51f69b39b752 100644
--- a/arch/x86/mm/init_64.c
+++ b/arch/x86/mm/init_64.c
@@ -340,7 +340,8 @@ phys_pte_update(pmd_t *pmd, unsigned long address, unsigned long end)
 }
 
 static unsigned long __meminit
-phys_pmd_init(pmd_t *pmd_page, unsigned long address, unsigned long end)
+phys_pmd_init(pmd_t *pmd_page, unsigned long address, unsigned long end,
+                         unsigned long page_size_mask)
 {
         unsigned long pages = 0;
 
@@ -365,7 +366,7 @@ phys_pmd_init(pmd_t *pmd_page, unsigned long address, unsigned long end)
                         continue;
                 }
 
-                if (cpu_has_pse) {
+                if (page_size_mask & (1<<PG_LEVEL_2M)) {
                         pages++;
                         set_pte((pte_t *)pmd,
                                 pfn_pte(address >> PAGE_SHIFT, PAGE_KERNEL_LARGE));
@@ -383,20 +384,22 @@ phys_pmd_init(pmd_t *pmd_page, unsigned long address, unsigned long end)
 }
 
 static unsigned long __meminit
-phys_pmd_update(pud_t *pud, unsigned long address, unsigned long end)
+phys_pmd_update(pud_t *pud, unsigned long address, unsigned long end,
+                         unsigned long page_size_mask)
 {
         pmd_t *pmd = pmd_offset(pud, 0);
         unsigned long last_map_addr;
 
         spin_lock(&init_mm.page_table_lock);
-        last_map_addr = phys_pmd_init(pmd, address, end);
+        last_map_addr = phys_pmd_init(pmd, address, end, page_size_mask);
         spin_unlock(&init_mm.page_table_lock);
         __flush_tlb_all();
         return last_map_addr;
 }
 
 static unsigned long __meminit
-phys_pud_init(pud_t *pud_page, unsigned long addr, unsigned long end)
+phys_pud_init(pud_t *pud_page, unsigned long addr, unsigned long end,
+                         unsigned long page_size_mask)
 {
         unsigned long pages = 0;
         unsigned long last_map_addr = end;
@@ -418,11 +421,12 @@ phys_pud_init(pud_t *pud_page, unsigned long addr, unsigned long end)
 
                 if (pud_val(*pud)) {
                         if (!pud_large(*pud))
-                                last_map_addr = phys_pmd_update(pud, addr, end);
+                                last_map_addr = phys_pmd_update(pud, addr, end,
+                                                         page_size_mask);
                         continue;
                 }
 
-                if (direct_gbpages) {
+                if (page_size_mask & (1<<PG_LEVEL_1G)) {
                         pages++;
                         set_pte((pte_t *)pud,
                                 pfn_pte(addr >> PAGE_SHIFT, PAGE_KERNEL_LARGE));
@@ -433,7 +437,7 @@ phys_pud_init(pud_t *pud_page, unsigned long addr, unsigned long end)
                 pmd = alloc_low_page(&pmd_phys);
 
                 spin_lock(&init_mm.page_table_lock);
-                last_map_addr = phys_pmd_init(pmd, addr, end);
+                last_map_addr = phys_pmd_init(pmd, addr, end, page_size_mask);
                 unmap_low_page(pmd);
                 pud_populate(&init_mm, pud, __va(pmd_phys));
                 spin_unlock(&init_mm.page_table_lock);
@@ -446,29 +450,37 @@ phys_pud_init(pud_t *pud_page, unsigned long addr, unsigned long end)
 }
 
 static unsigned long __meminit
-phys_pud_update(pgd_t *pgd, unsigned long addr, unsigned long end)
+phys_pud_update(pgd_t *pgd, unsigned long addr, unsigned long end,
+                 unsigned long page_size_mask)
 {
         pud_t *pud;
 
         pud = (pud_t *)pgd_page_vaddr(*pgd);
 
-        return phys_pud_init(pud, addr, end);
+        return phys_pud_init(pud, addr, end, page_size_mask);
 }
 
 static void __init find_early_table_space(unsigned long end)
 {
-        unsigned long puds, tables, start;
+        unsigned long puds, pmds, ptes, tables, start;
 
         puds = (end + PUD_SIZE - 1) >> PUD_SHIFT;
         tables = round_up(puds * sizeof(pud_t), PAGE_SIZE);
-        if (!direct_gbpages) {
-                unsigned long pmds = (end + PMD_SIZE - 1) >> PMD_SHIFT;
-                tables += round_up(pmds * sizeof(pmd_t), PAGE_SIZE);
-        }
-        if (!cpu_has_pse) {
-                unsigned long ptes = (end + PAGE_SIZE - 1) >> PAGE_SHIFT;
-                tables += round_up(ptes * sizeof(pte_t), PAGE_SIZE);
-        }
+        if (direct_gbpages) {
+                unsigned long extra;
+                extra = end - ((end>>PUD_SHIFT) << PUD_SHIFT);
+                pmds = (extra + PMD_SIZE - 1) >> PMD_SHIFT;
+        } else
+                pmds = (end + PMD_SIZE - 1) >> PMD_SHIFT;
+        tables += round_up(pmds * sizeof(pmd_t), PAGE_SIZE);
+
+        if (cpu_has_pse) {
+                unsigned long extra;
+                extra = end - ((end>>PMD_SHIFT) << PMD_SHIFT);
+                ptes = (extra + PAGE_SIZE - 1) >> PAGE_SHIFT;
+        } else
+                ptes = (end + PAGE_SIZE - 1) >> PAGE_SHIFT;
+        tables += round_up(ptes * sizeof(pte_t), PAGE_SIZE);
 
         /*
          * RED-PEN putting page tables only on node 0 could
@@ -608,29 +620,12 @@ static void __init early_memtest(unsigned long start, unsigned long end)
 }
 #endif
 
-/*
- * Setup the direct mapping of the physical memory at PAGE_OFFSET.
- * This runs before bootmem is initialized and gets pages directly from
- * the physical memory. To access them they are temporarily mapped.
- */
-unsigned long __init_refok init_memory_mapping(unsigned long start, unsigned long end)
+static unsigned long __init kernel_physical_mapping_init(unsigned long start,
+                                                unsigned long end,
+                                                unsigned long page_size_mask)
 {
-        unsigned long next, last_map_addr = end;
-        unsigned long start_phys = start, end_phys = end;
-
-        printk(KERN_INFO "init_memory_mapping\n");
 
-        /*
-         * Find space for the kernel direct mapping tables.
-         *
-         * Later we should allocate these tables in the local node of the
-         * memory mapped. Unfortunately this is done currently before the
-         * nodes are discovered.
-         */
-        if (!after_bootmem) {
-                init_gbpages();
-                find_early_table_space(end);
-        }
+        unsigned long next, last_map_addr = end;
 
         start = (unsigned long)__va(start);
         end = (unsigned long)__va(end);
@@ -645,7 +640,8 @@ unsigned long __init_refok init_memory_mapping(unsigned long start, unsigned lon
                         next = end;
 
                 if (pgd_val(*pgd)) {
-                        last_map_addr = phys_pud_update(pgd, __pa(start), __pa(end));
+                        last_map_addr = phys_pud_update(pgd, __pa(start),
+                                                 __pa(end), page_size_mask);
                         continue;
                 }
 
@@ -654,22 +650,107 @@ unsigned long __init_refok init_memory_mapping(unsigned long start, unsigned lon
                 else
                         pud = alloc_low_page(&pud_phys);
 
-                last_map_addr = phys_pud_init(pud, __pa(start), __pa(next));
+                last_map_addr = phys_pud_init(pud, __pa(start), __pa(next),
+                                                 page_size_mask);
                 unmap_low_page(pud);
                 pgd_populate(&init_mm, pgd_offset_k(start),
                              __va(pud_phys));
         }
 
+        return last_map_addr;
+}
+/*
+ * Setup the direct mapping of the physical memory at PAGE_OFFSET.
+ * This runs before bootmem is initialized and gets pages directly from
+ * the physical memory. To access them they are temporarily mapped.
+ */
+unsigned long __init_refok init_memory_mapping(unsigned long start,
+                                               unsigned long end)
+{
+        unsigned long last_map_addr = end;
+        unsigned long page_size_mask = 0;
+        unsigned long start_pfn, end_pfn;
+
+        printk(KERN_INFO "init_memory_mapping\n");
+
+        /*
+         * Find space for the kernel direct mapping tables.
+         *
+         * Later we should allocate these tables in the local node of the
+         * memory mapped. Unfortunately this is done currently before the
+         * nodes are discovered.
+         */
+        if (!after_bootmem) {
+                init_gbpages();
+                find_early_table_space(end);
+        }
+
+        if (direct_gbpages)
+                page_size_mask |= 1 << PG_LEVEL_1G;
+        if (cpu_has_pse)
+                page_size_mask |= 1 << PG_LEVEL_2M;
+
+        /* head if not big page aligment ?*/
+        start_pfn = start >> PAGE_SHIFT;
+        end_pfn = ((start + (PMD_SIZE - 1)) >> PMD_SHIFT)
+                        << (PMD_SHIFT - PAGE_SHIFT);
+        if (start_pfn < end_pfn)
+                last_map_addr = kernel_physical_mapping_init(
+                                        start_pfn<<PAGE_SHIFT,
+                                        end_pfn<<PAGE_SHIFT, 0);
+
+        /* big page (2M) range*/
+        start_pfn = ((start + (PMD_SIZE - 1))>>PMD_SHIFT)
+                         << (PMD_SHIFT - PAGE_SHIFT);
+        end_pfn = ((start + (PUD_SIZE - 1))>>PUD_SHIFT)
+                         << (PUD_SHIFT - PAGE_SHIFT);
+        if (end_pfn > ((end>>PUD_SHIFT)<<(PUD_SHIFT - PAGE_SHIFT)))
+                end_pfn = ((end>>PUD_SHIFT)<<(PUD_SHIFT - PAGE_SHIFT));
+        if (start_pfn < end_pfn)
+                last_map_addr = kernel_physical_mapping_init(
+                                             start_pfn<<PAGE_SHIFT,
+                                             end_pfn<<PAGE_SHIFT,
+                                             page_size_mask & (1<<PG_LEVEL_2M));
+
+        /* big page (1G) range */
+        start_pfn = end_pfn;
+        end_pfn = (end>>PUD_SHIFT) << (PUD_SHIFT - PAGE_SHIFT);
+        if (start_pfn < end_pfn)
+                last_map_addr = kernel_physical_mapping_init(
+                                             start_pfn<<PAGE_SHIFT,
+                                             end_pfn<<PAGE_SHIFT,
+                                             page_size_mask & ((1<<PG_LEVEL_2M)
+                                                         | (1<<PG_LEVEL_1G)));
+
+        /* tail is not big page (1G) alignment */
+        start_pfn = end_pfn;
+        end_pfn = (end>>PMD_SHIFT) << (PMD_SHIFT - PAGE_SHIFT);
+        if (start_pfn < end_pfn)
+                last_map_addr = kernel_physical_mapping_init(
+                                             start_pfn<<PAGE_SHIFT,
+                                             end_pfn<<PAGE_SHIFT,
+                                             page_size_mask & (1<<PG_LEVEL_2M));
+        /* tail is not big page (2M) alignment */
+        start_pfn = end_pfn;
+        end_pfn = end>>PAGE_SHIFT;
+        if (start_pfn < end_pfn)
+                last_map_addr = kernel_physical_mapping_init(
+                                             start_pfn<<PAGE_SHIFT,
+                                             end_pfn<<PAGE_SHIFT, 0);
+
         if (!after_bootmem)
                 mmu_cr4_features = read_cr4();
         __flush_tlb_all();
 
-        if (!after_bootmem)
+        if (!after_bootmem && table_end > table_start)
                 reserve_early(table_start << PAGE_SHIFT,
                                  table_end << PAGE_SHIFT, "PGTABLE");
 
+        printk(KERN_INFO "last_map_addr: %lx end: %lx\n",
+                         last_map_addr, end);
+
         if (!after_bootmem)
-                early_memtest(start_phys, end_phys);
+                early_memtest(start, end);
 
         return last_map_addr >> PAGE_SHIFT;
 }
@@ -1076,9 +1157,6 @@ vmemmap_populate(struct page *start_page, unsigned long size, int node)
                                                 PAGE_KERNEL_LARGE);
                                 set_pmd(pmd, __pmd(pte_val(entry)));
 
-                                addr_end = addr + PMD_SIZE;
-                                p_end = p + PMD_SIZE;
-
                                 /* check to see if we have contiguous blocks */
                                 if (p_end != p || node_start != node) {
                                         if (p_start)
@@ -1088,6 +1166,9 @@ vmemmap_populate(struct page *start_page, unsigned long size, int node)
                                         node_start = node;
                                         p_start = p;
                                 }
+
+                                addr_end = addr + PMD_SIZE;
+                                p_end = p + PMD_SIZE;
                         } else
                                 vmemmap_verify((pte_t *)pmd, node, addr, next);
                 }
diff --git a/include/asm-x86/e820.h b/include/asm-x86/e820.h
index a20d0a7f5892..78c03d7bf441 100644
--- a/include/asm-x86/e820.h
+++ b/include/asm-x86/e820.h
@@ -99,7 +99,7 @@ extern void free_early(u64 start, u64 end);
 extern void early_res_to_bootmem(u64 start, u64 end);
 extern u64 early_reserve_e820(u64 startt, u64 sizet, u64 align);
 
-extern unsigned long e820_end_of_ram(void);
+extern unsigned long e820_end(void);
 extern int e820_find_active_region(const struct e820entry *ei,
                                   unsigned long start_pfn,
                                   unsigned long last_pfn,
diff --git a/include/asm-x86/genapic_32.h b/include/asm-x86/genapic_32.h
index b02ea6e17de8..8d4c8bdb9065 100644
--- a/include/asm-x86/genapic_32.h
+++ b/include/asm-x86/genapic_32.h
@@ -119,5 +119,6 @@ enum uv_system_type {UV_NONE, UV_LEGACY_APIC, UV_X2APIC, UV_NON_UNIQUE_APIC};
 #define is_uv_system()                  0
 #define uv_wakeup_secondary(a, b)       1
 
+extern void force_mask_ioapic_irq_2(void);
 
 #endif
diff --git a/include/asm-x86/genapic_64.h b/include/asm-x86/genapic_64.h
index 0f8504627c41..082ad020e412 100644
--- a/include/asm-x86/genapic_64.h
+++ b/include/asm-x86/genapic_64.h
@@ -46,4 +46,6 @@ extern int uv_wakeup_secondary(int phys_apicid, unsigned int start_rip);
 
 extern void setup_apic_routing(void);
 
+extern void force_mask_ioapic_irq_2(void);
+
 #endif