Merge branch 'for-linus' of git://one.firstfloor.org/home/andi/git/linux-2.6

* 'for-linus' of git://one.firstfloor.org/home/andi/git/linux-2.6: (225 commits)
  [PATCH] Don't set calgary iommu as default y
  [PATCH] i386/x86-64: New Intel feature flags
  [PATCH] x86: Add a cumulative thermal throttle event counter.
  [PATCH] i386: Make the jiffies compares use the 64bit safe macros.
  [PATCH] x86: Refactor thermal throttle processing
  [PATCH] Add 64bit jiffies compares (for use with get_jiffies_64)
  [PATCH] Fix unwinder warning in traps.c
  [PATCH] x86: Allow disabling early pci scans with pci=noearly or disallowing conf1
  [PATCH] x86: Move direct PCI scanning functions out of line
  [PATCH] i386/x86-64: Make all early PCI scans dependent on CONFIG_PCI
  [PATCH] Don't leak NT bit into next task
  [PATCH] i386/x86-64: Work around gcc bug with noreturn functions in unwinder
  [PATCH] Fix some broken white space in ia32_signal.c
  [PATCH] Initialize argument registers for 32bit signal handlers.
  [PATCH] Remove all traces of signal number conversion
  [PATCH] Don't synchronize time reading on single core AMD systems
  [PATCH] Remove outdated comment in x86-64 mmconfig code
  [PATCH] Use string instructions for Core2 copy/clear
  [PATCH] x86: - restore i8259A eoi status on resume
  [PATCH] i386: Split multi-line printk in oops output.
  ...

3 files changed, 179 insertions, 10 deletions

diff --git a/arch/i386/kernel/acpi/Makefile b/arch/i386/kernel/acpi/Makefile
index 7e9ac99354f4..7f7be01f44e6 100644
--- a/arch/i386/kernel/acpi/Makefile
+++ b/arch/i386/kernel/acpi/Makefile
@@ -1,5 +1,7 @@
 obj-$(CONFIG_ACPI)              += boot.o
+ifneq ($(CONFIG_PCI),)
 obj-$(CONFIG_X86_IO_APIC)       += earlyquirk.o
+endif
 obj-$(CONFIG_ACPI_SLEEP)        += sleep.o wakeup.o
 
 ifneq ($(CONFIG_ACPI_PROCESSOR),)
diff --git a/arch/i386/kernel/acpi/boot.c b/arch/i386/kernel/acpi/boot.c
index ee003bc0e8b1..1aaea6ab8c46 100644
--- a/arch/i386/kernel/acpi/boot.c
+++ b/arch/i386/kernel/acpi/boot.c
@@ -26,9 +26,12 @@
 #include <linux/init.h>
 #include <linux/acpi.h>
 #include <linux/efi.h>
+#include <linux/cpumask.h>
 #include <linux/module.h>
 #include <linux/dmi.h>
 #include <linux/irq.h>
+#include <linux/bootmem.h>
+#include <linux/ioport.h>
 
 #include <asm/pgtable.h>
 #include <asm/io_apic.h>
@@ -36,11 +39,17 @@
 #include <asm/io.h>
 #include <asm/mpspec.h>
 
-#ifdef  CONFIG_X86_64
+static int __initdata acpi_force = 0;
 
-extern void __init clustered_apic_check(void);
+#ifdef  CONFIG_ACPI
+int acpi_disabled = 0;
+#else
+int acpi_disabled = 1;
+#endif
+EXPORT_SYMBOL(acpi_disabled);
+
+#ifdef  CONFIG_X86_64
 
-extern int gsi_irq_sharing(int gsi);
 #include <asm/proto.h>
 
 static inline int acpi_madt_oem_check(char *oem_id, char *oem_table_id) { return 0; }
@@ -506,16 +515,76 @@ EXPORT_SYMBOL(acpi_register_gsi);
 #ifdef CONFIG_ACPI_HOTPLUG_CPU
 int acpi_map_lsapic(acpi_handle handle, int *pcpu)
 {
-        /* TBD */
-        return -EINVAL;
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+        struct acpi_table_lapic *lapic;
+        cpumask_t tmp_map, new_map;
+        u8 physid;
+        int cpu;
+
+        if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
+                return -EINVAL;
+
+        if (!buffer.length || !buffer.pointer)
+                return -EINVAL;
+
+        obj = buffer.pointer;
+        if (obj->type != ACPI_TYPE_BUFFER ||
+            obj->buffer.length < sizeof(*lapic)) {
+                kfree(buffer.pointer);
+                return -EINVAL;
+        }
+
+        lapic = (struct acpi_table_lapic *)obj->buffer.pointer;
+
+        if ((lapic->header.type != ACPI_MADT_LAPIC) ||
+            (!lapic->flags.enabled)) {
+                kfree(buffer.pointer);
+                return -EINVAL;
+        }
+
+        physid = lapic->id;
+
+        kfree(buffer.pointer);
+        buffer.length = ACPI_ALLOCATE_BUFFER;
+        buffer.pointer = NULL;
+
+        tmp_map = cpu_present_map;
+        mp_register_lapic(physid, lapic->flags.enabled);
+
+        /*
+         * If mp_register_lapic successfully generates a new logical cpu
+         * number, then the following will get us exactly what was mapped
+         */
+        cpus_andnot(new_map, cpu_present_map, tmp_map);
+        if (cpus_empty(new_map)) {
+                printk ("Unable to map lapic to logical cpu number\n");
+                return -EINVAL;
+        }
+
+        cpu = first_cpu(new_map);
+
+        *pcpu = cpu;
+        return 0;
 }
 
 EXPORT_SYMBOL(acpi_map_lsapic);
 
 int acpi_unmap_lsapic(int cpu)
 {
-        /* TBD */
-        return -EINVAL;
+        int i;
+
+        for_each_possible_cpu(i) {
+                if (x86_acpiid_to_apicid[i] == x86_cpu_to_apicid[cpu]) {
+                        x86_acpiid_to_apicid[i] = -1;
+                        break;
+                }
+        }
+        x86_cpu_to_apicid[cpu] = -1;
+        cpu_clear(cpu, cpu_present_map);
+        num_processors--;
+
+        return (0);
 }
 
 EXPORT_SYMBOL(acpi_unmap_lsapic);
@@ -579,6 +648,8 @@ static int __init acpi_parse_sbf(unsigned long phys_addr, unsigned long size)
 static int __init acpi_parse_hpet(unsigned long phys, unsigned long size)
 {
         struct acpi_table_hpet *hpet_tbl;
+        struct resource *hpet_res;
+        resource_size_t res_start;
 
         if (!phys || !size)
                 return -EINVAL;
@@ -594,12 +665,26 @@ static int __init acpi_parse_hpet(unsigned long phys, unsigned long size)
                        "memory.\n");
                 return -1;
         }
+
+#define HPET_RESOURCE_NAME_SIZE 9
+        hpet_res = alloc_bootmem(sizeof(*hpet_res) + HPET_RESOURCE_NAME_SIZE);
+        if (hpet_res) {
+                memset(hpet_res, 0, sizeof(*hpet_res));
+                hpet_res->name = (void *)&hpet_res[1];
+                hpet_res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
+                snprintf((char *)hpet_res->name, HPET_RESOURCE_NAME_SIZE,
+                         "HPET %u", hpet_tbl->number);
+                hpet_res->end = (1 * 1024) - 1;
+        }
+
 #ifdef  CONFIG_X86_64
         vxtime.hpet_address = hpet_tbl->addr.addrl |
             ((long)hpet_tbl->addr.addrh << 32);
 
         printk(KERN_INFO PREFIX "HPET id: %#x base: %#lx\n",
                hpet_tbl->id, vxtime.hpet_address);
+
+        res_start = vxtime.hpet_address;
 #else                           /* X86 */
         {
                 extern unsigned long hpet_address;
@@ -607,9 +692,17 @@ static int __init acpi_parse_hpet(unsigned long phys, unsigned long size)
                 hpet_address = hpet_tbl->addr.addrl;
                 printk(KERN_INFO PREFIX "HPET id: %#x base: %#lx\n",
                        hpet_tbl->id, hpet_address);
+
+                res_start = hpet_address;
         }
 #endif                          /* X86 */
 
+        if (hpet_res) {
+                hpet_res->start = res_start;
+                hpet_res->end += res_start;
+                insert_resource(&iomem_resource, hpet_res);
+        }
+
         return 0;
 }
 #else
@@ -860,8 +953,6 @@ static void __init acpi_process_madt(void)
         return;
 }
 
-extern int acpi_force;
-
 #ifdef __i386__
 
 static int __init disable_acpi_irq(struct dmi_system_id *d)
@@ -1163,3 +1254,75 @@ int __init acpi_boot_init(void)
 
         return 0;
 }
+
+static int __init parse_acpi(char *arg)
+{
+        if (!arg)
+                return -EINVAL;
+
+        /* "acpi=off" disables both ACPI table parsing and interpreter */
+        if (strcmp(arg, "off") == 0) {
+                disable_acpi();
+        }
+        /* acpi=force to over-ride black-list */
+        else if (strcmp(arg, "force") == 0) {
+                acpi_force = 1;
+                acpi_ht = 1;
+                acpi_disabled = 0;
+        }
+        /* acpi=strict disables out-of-spec workarounds */
+        else if (strcmp(arg, "strict") == 0) {
+                acpi_strict = 1;
+        }
+        /* Limit ACPI just to boot-time to enable HT */
+        else if (strcmp(arg, "ht") == 0) {
+                if (!acpi_force)
+                        disable_acpi();
+                acpi_ht = 1;
+        }
+        /* "acpi=noirq" disables ACPI interrupt routing */
+        else if (strcmp(arg, "noirq") == 0) {
+                acpi_noirq_set();
+        } else {
+                /* Core will printk when we return error. */
+                return -EINVAL;
+        }
+        return 0;
+}
+early_param("acpi", parse_acpi);
+
+/* FIXME: Using pci= for an ACPI parameter is a travesty. */
+static int __init parse_pci(char *arg)
+{
+        if (arg && strcmp(arg, "noacpi") == 0)
+                acpi_disable_pci();
+        return 0;
+}
+early_param("pci", parse_pci);
+
+#ifdef CONFIG_X86_IO_APIC
+static int __init parse_acpi_skip_timer_override(char *arg)
+{
+        acpi_skip_timer_override = 1;
+        return 0;
+}
+early_param("acpi_skip_timer_override", parse_acpi_skip_timer_override);
+#endif /* CONFIG_X86_IO_APIC */
+
+static int __init setup_acpi_sci(char *s)
+{
+        if (!s)
+                return -EINVAL;
+        if (!strcmp(s, "edge"))
+                acpi_sci_flags.trigger = 1;
+        else if (!strcmp(s, "level"))
+                acpi_sci_flags.trigger = 3;
+        else if (!strcmp(s, "high"))
+                acpi_sci_flags.polarity = 1;
+        else if (!strcmp(s, "low"))
+                acpi_sci_flags.polarity = 3;
+        else
+                return -EINVAL;
+        return 0;
+}
+early_param("acpi_sci", setup_acpi_sci);
diff --git a/arch/i386/kernel/acpi/earlyquirk.c b/arch/i386/kernel/acpi/earlyquirk.c
index 1649a175a206..fe799b11ac0a 100644
--- a/arch/i386/kernel/acpi/earlyquirk.c
+++ b/arch/i386/kernel/acpi/earlyquirk.c
@@ -48,7 +48,11 @@ void __init check_acpi_pci(void)
         int num, slot, func;
 
         /* Assume the machine supports type 1. If not it will 
-           always read ffffffff and should not have any side effect. */
+           always read ffffffff and should not have any side effect.
+           Actually a few buggy systems can machine check. Allow the user
+           to disable it by command line option at least -AK */
+        if (!early_pci_allowed())
+                return;
 
         /* Poor man's PCI discovery */
         for (num = 0; num < 32; num++) {