16 files changed, 276 insertions, 218 deletions

diff --git a/arch/ia64/Kconfig b/arch/ia64/Kconfig
index 8e5517e62c0a..845cd0902a50 100644
--- a/arch/ia64/Kconfig
+++ b/arch/ia64/Kconfig
@@ -194,7 +194,6 @@ config IA64_L1_CACHE_SHIFT
         default "7" if MCKINLEY
         default "6" if ITANIUM
 
-# align cache-sensitive data to 64 bytes
 config IA64_CYCLONE
         bool "Cyclone (EXA) Time Source support"
         help
diff --git a/arch/ia64/kernel/Makefile b/arch/ia64/kernel/Makefile
index 307514f7a282..09a0dbc17fb6 100644
--- a/arch/ia64/kernel/Makefile
+++ b/arch/ia64/kernel/Makefile
@@ -13,6 +13,11 @@ obj-$(CONFIG_IA64_BRL_EMU)	+= brl_emu.o
 obj-$(CONFIG_IA64_GENERIC)      += acpi-ext.o
 obj-$(CONFIG_IA64_HP_ZX1)       += acpi-ext.o
 obj-$(CONFIG_IA64_HP_ZX1_SWIOTLB) += acpi-ext.o
+
+ifneq ($(CONFIG_ACPI_PROCESSOR),)
+obj-y                           += acpi-processor.o
+endif
+
 obj-$(CONFIG_IA64_PALINFO)      += palinfo.o
 obj-$(CONFIG_IOSAPIC)           += iosapic.o
 obj-$(CONFIG_MODULES)           += module.o
diff --git a/arch/ia64/kernel/acpi-ext.c b/arch/ia64/kernel/acpi-ext.c
index 13a5b3b49bf8..4a5574ff007b 100644
--- a/arch/ia64/kernel/acpi-ext.c
+++ b/arch/ia64/kernel/acpi-ext.c
@@ -33,33 +33,33 @@ acpi_vendor_resource_match(struct acpi_resource *resource, void *context)
         struct acpi_vendor_info *info = (struct acpi_vendor_info *)context;
         struct acpi_resource_vendor *vendor;
         struct acpi_vendor_descriptor *descriptor;
-        u32 length;
+        u32 byte_length;
 
-        if (resource->id != ACPI_RSTYPE_VENDOR)
+        if (resource->type != ACPI_RESOURCE_TYPE_VENDOR)
                 return AE_OK;
 
         vendor = (struct acpi_resource_vendor *)&resource->data;
-        descriptor = (struct acpi_vendor_descriptor *)vendor->reserved;
-        if (vendor->length <= sizeof(*info->descriptor) ||
+        descriptor = (struct acpi_vendor_descriptor *)vendor->byte_data;
+        if (vendor->byte_length <= sizeof(*info->descriptor) ||
             descriptor->guid_id != info->descriptor->guid_id ||
             efi_guidcmp(descriptor->guid, info->descriptor->guid))
                 return AE_OK;
 
-        length = vendor->length - sizeof(struct acpi_vendor_descriptor);
-        info->data = acpi_os_allocate(length);
+        byte_length = vendor->byte_length - sizeof(struct acpi_vendor_descriptor);
+        info->data = acpi_os_allocate(byte_length);
         if (!info->data)
                 return AE_NO_MEMORY;
 
         memcpy(info->data,
-               vendor->reserved + sizeof(struct acpi_vendor_descriptor),
-               length);
-        info->length = length;
+               vendor->byte_data + sizeof(struct acpi_vendor_descriptor),
+               byte_length);
+        info->length = byte_length;
         return AE_CTRL_TERMINATE;
 }
 
 acpi_status
 acpi_find_vendor_resource(acpi_handle obj, struct acpi_vendor_descriptor * id,
-                          u8 ** data, u32 * length)
+                          u8 ** data, u32 * byte_length)
 {
         struct acpi_vendor_info info;
 
@@ -72,7 +72,7 @@ acpi_find_vendor_resource(acpi_handle obj, struct acpi_vendor_descriptor * id,
                 return AE_NOT_FOUND;
 
         *data = info.data;
-        *length = info.length;
+        *byte_length = info.length;
         return AE_OK;
 }
 
diff --git a/arch/ia64/kernel/acpi-processor.c b/arch/ia64/kernel/acpi-processor.c
new file mode 100644
index 000000000000..e683630c8ce2
--- /dev/null
+++ b/arch/ia64/kernel/acpi-processor.c
@@ -0,0 +1,67 @@
+/*
+ * arch/ia64/kernel/cpufreq/processor.c
+ *
+ * Copyright (C) 2005 Intel Corporation
+ *      Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
+ *      - Added _PDC for platforms with Intel CPUs
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/acpi.h>
+
+#include <acpi/processor.h>
+#include <asm/acpi.h>
+
+static void init_intel_pdc(struct acpi_processor *pr)
+{
+        struct acpi_object_list *obj_list;
+        union acpi_object *obj;
+        u32 *buf;
+
+        /* allocate and initialize pdc. It will be used later. */
+        obj_list = kmalloc(sizeof(struct acpi_object_list), GFP_KERNEL);
+        if (!obj_list) {
+                printk(KERN_ERR "Memory allocation error\n");
+                return;
+        }
+
+        obj = kmalloc(sizeof(union acpi_object), GFP_KERNEL);
+        if (!obj) {
+                printk(KERN_ERR "Memory allocation error\n");
+                kfree(obj_list);
+                return;
+        }
+
+        buf = kmalloc(12, GFP_KERNEL);
+        if (!buf) {
+                printk(KERN_ERR "Memory allocation error\n");
+                kfree(obj);
+                kfree(obj_list);
+                return;
+        }
+
+        buf[0] = ACPI_PDC_REVISION_ID;
+        buf[1] = 1;
+        buf[2] |= ACPI_PDC_EST_CAPABILITY_SMP;
+
+        obj->type = ACPI_TYPE_BUFFER;
+        obj->buffer.length = 12;
+        obj->buffer.pointer = (u8 *) buf;
+        obj_list->count = 1;
+        obj_list->pointer = obj;
+        pr->pdc = obj_list;
+
+        return;
+}
+
+/* Initialize _PDC data based on the CPU vendor */
+void arch_acpi_processor_init_pdc(struct acpi_processor *pr)
+{
+        pr->pdc = NULL;
+        init_intel_pdc(pr);
+        return;
+}
+
+EXPORT_SYMBOL(arch_acpi_processor_init_pdc);
diff --git a/arch/ia64/kernel/acpi.c b/arch/ia64/kernel/acpi.c
index 9ad94ddf6687..d2702c419cf8 100644
--- a/arch/ia64/kernel/acpi.c
+++ b/arch/ia64/kernel/acpi.c
@@ -567,16 +567,16 @@ void __init acpi_numa_arch_fixup(void)
  * success: return IRQ number (>=0)
  * failure: return < 0
  */
-int acpi_register_gsi(u32 gsi, int edge_level, int active_high_low)
+int acpi_register_gsi(u32 gsi, int triggering, int polarity)
 {
         if (has_8259 && gsi < 16)
                 return isa_irq_to_vector(gsi);
 
         return iosapic_register_intr(gsi,
-                                     (active_high_low ==
+                                     (polarity ==
                                       ACPI_ACTIVE_HIGH) ? IOSAPIC_POL_HIGH :
                                      IOSAPIC_POL_LOW,
-                                     (edge_level ==
+                                     (triggering ==
                                       ACPI_EDGE_SENSITIVE) ? IOSAPIC_EDGE :
                                      IOSAPIC_LEVEL);
 }
diff --git a/arch/ia64/kernel/cpufreq/Makefile b/arch/ia64/kernel/cpufreq/Makefile
index f748d34c02f0..4838f2a57c7a 100644
--- a/arch/ia64/kernel/cpufreq/Makefile
+++ b/arch/ia64/kernel/cpufreq/Makefile
@@ -1 +1,2 @@
 obj-$(CONFIG_IA64_ACPI_CPUFREQ)         += acpi-cpufreq.o
+
diff --git a/arch/ia64/kernel/cpufreq/acpi-cpufreq.c b/arch/ia64/kernel/cpufreq/acpi-cpufreq.c
index da4d5cf80a48..5a1bf815282d 100644
--- a/arch/ia64/kernel/cpufreq/acpi-cpufreq.c
+++ b/arch/ia64/kernel/cpufreq/acpi-cpufreq.c
@@ -269,48 +269,6 @@ acpi_cpufreq_verify (
 }
 
 
-/*
- * processor_init_pdc - let BIOS know about the SMP capabilities
- * of this driver
- * @perf: processor-specific acpi_io_data struct
- * @cpu: CPU being initialized
- *
- * To avoid issues with legacy OSes, some BIOSes require to be informed of
- * the SMP capabilities of OS P-state driver. Here we set the bits in _PDC
- * accordingly. Actual call to _PDC is done in driver/acpi/processor.c
- */
-static void
-processor_init_pdc (
-                struct acpi_processor_performance *perf,
-                unsigned int cpu,
-                struct acpi_object_list *obj_list
-                )
-{
-        union acpi_object *obj;
-        u32 *buf;
-
-        dprintk("processor_init_pdc\n");
-
-        perf->pdc = NULL;
-        /* Initialize pdc. It will be used later. */
-        if (!obj_list)
-                return;
-
-        if (!(obj_list->count && obj_list->pointer))
-                return;
-
-        obj = obj_list->pointer;
-        if ((obj->buffer.length == 12) && obj->buffer.pointer) {
-                buf = (u32 *)obj->buffer.pointer;
-                buf[0] = ACPI_PDC_REVISION_ID;
-                buf[1] = 1;
-                buf[2] = ACPI_PDC_EST_CAPABILITY_SMP;
-                perf->pdc = obj_list;
-        }
-        return;
-}
-
-
 static int
 acpi_cpufreq_cpu_init (
         struct cpufreq_policy   *policy)
@@ -320,14 +278,7 @@ acpi_cpufreq_cpu_init (
         struct cpufreq_acpi_io  *data;
         unsigned int            result = 0;
 
-        union acpi_object               arg0 = {ACPI_TYPE_BUFFER};
-        u32                             arg0_buf[3];
-        struct acpi_object_list         arg_list = {1, &arg0};
-
         dprintk("acpi_cpufreq_cpu_init\n");
-        /* setup arg_list for _PDC settings */
-        arg0.buffer.length = 12;
-        arg0.buffer.pointer = (u8 *) arg0_buf;
 
         data = kmalloc(sizeof(struct cpufreq_acpi_io), GFP_KERNEL);
         if (!data)
@@ -337,9 +288,7 @@ acpi_cpufreq_cpu_init (
 
         acpi_io_data[cpu] = data;
 
-        processor_init_pdc(&data->acpi_data, cpu, &arg_list);
         result = acpi_processor_register_performance(&data->acpi_data, cpu);
-        data->acpi_data.pdc = NULL;
 
         if (result)
                 goto err_free;
diff --git a/arch/ia64/kernel/mca_asm.S b/arch/ia64/kernel/mca_asm.S
index 403a80a58c13..60a464bfd9e2 100644
--- a/arch/ia64/kernel/mca_asm.S
+++ b/arch/ia64/kernel/mca_asm.S
@@ -512,7 +512,7 @@ ia64_state_save:
         st8 [temp1]=r12         // os_status, default is cold boot
         mov r6=IA64_MCA_SAME_CONTEXT
         ;;
-        st8 [temp1]=r6          // context, default is same context
+        st8 [temp2]=r6          // context, default is same context
 
         // Save the pt_regs data that is not in minstate.  The previous code
         // left regs at sos.
diff --git a/arch/ia64/kernel/sal.c b/arch/ia64/kernel/sal.c
index acc0f132f86c..056f7a6eedc7 100644
--- a/arch/ia64/kernel/sal.c
+++ b/arch/ia64/kernel/sal.c
@@ -14,6 +14,7 @@
 #include <linux/spinlock.h>
 #include <linux/string.h>
 
+#include <asm/delay.h>
 #include <asm/page.h>
 #include <asm/sal.h>
 #include <asm/pal.h>
@@ -214,6 +215,78 @@ chk_nointroute_opt(void)
 static void __init sal_desc_ap_wakeup(void *p) { }
 #endif
 
+/*
+ * HP rx5670 firmware polls for interrupts during SAL_CACHE_FLUSH by reading
+ * cr.ivr, but it never writes cr.eoi.  This leaves any interrupt marked as
+ * "in-service" and masks other interrupts of equal or lower priority.
+ *
+ * HP internal defect reports: F1859, F2775, F3031.
+ */
+static int sal_cache_flush_drops_interrupts;
+
+static void __init
+check_sal_cache_flush (void)
+{
+        unsigned long flags, itv;
+        int cpu;
+        u64 vector;
+
+        cpu = get_cpu();
+        local_irq_save(flags);
+
+        /*
+         * Schedule a timer interrupt, wait until it's reported, and see if
+         * SAL_CACHE_FLUSH drops it.
+         */
+        itv = ia64_get_itv();
+        BUG_ON((itv & (1 << 16)) == 0);
+
+        ia64_set_itv(IA64_TIMER_VECTOR);
+        ia64_set_itm(ia64_get_itc() + 1000);
+
+        while (!ia64_get_irr(IA64_TIMER_VECTOR))
+                cpu_relax();
+
+        ia64_sal_cache_flush(3);
+
+        if (ia64_get_irr(IA64_TIMER_VECTOR)) {
+                vector = ia64_get_ivr();
+                ia64_eoi();
+                WARN_ON(vector != IA64_TIMER_VECTOR);
+        } else {
+                sal_cache_flush_drops_interrupts = 1;
+                printk(KERN_ERR "SAL: SAL_CACHE_FLUSH drops interrupts; "
+                        "PAL_CACHE_FLUSH will be used instead\n");
+                ia64_eoi();
+        }
+
+        ia64_set_itv(itv);
+        local_irq_restore(flags);
+        put_cpu();
+}
+
+s64
+ia64_sal_cache_flush (u64 cache_type)
+{
+        struct ia64_sal_retval isrv;
+
+        if (sal_cache_flush_drops_interrupts) {
+                unsigned long flags;
+                u64 progress;
+                s64 rc;
+
+                progress = 0;
+                local_irq_save(flags);
+                rc = ia64_pal_cache_flush(cache_type,
+                        PAL_CACHE_FLUSH_INVALIDATE, &progress, NULL);
+                local_irq_restore(flags);
+                return rc;
+        }
+
+        SAL_CALL(isrv, SAL_CACHE_FLUSH, cache_type, 0, 0, 0, 0, 0, 0);
+        return isrv.status;
+}
+
 void __init
 ia64_sal_init (struct ia64_sal_systab *systab)
 {
@@ -262,6 +335,8 @@ ia64_sal_init (struct ia64_sal_systab *systab)
                 }
                 p += SAL_DESC_SIZE(*p);
         }
+
+        check_sal_cache_flush();
 }
 
 int
diff --git a/arch/ia64/kernel/unaligned.c b/arch/ia64/kernel/unaligned.c
index 43b45b65ee5a..f9e0ae936d1a 100644
--- a/arch/ia64/kernel/unaligned.c
+++ b/arch/ia64/kernel/unaligned.c
@@ -1283,8 +1283,9 @@ within_logging_rate_limit (void)
 
         if (jiffies - last_time > 5*HZ)
                 count = 0;
-        if (++count < 5) {
+        if (count < 5) {
                 last_time = jiffies;
+                count++;
                 return 1;
         }
         return 0;
diff --git a/arch/ia64/pci/pci.c b/arch/ia64/pci/pci.c
index d27ecdcb6fca..0b30ca006286 100644
--- a/arch/ia64/pci/pci.c
+++ b/arch/ia64/pci/pci.c
@@ -193,12 +193,12 @@ add_io_space (struct pci_root_info *info, struct acpi_resource_address64 *addr)
                 goto free_resource;
         }
 
-        min = addr->min_address_range;
+        min = addr->minimum;
         max = min + addr->address_length - 1;
-        if (addr->attribute.io.translation_attribute == ACPI_SPARSE_TRANSLATION)
+        if (addr->info.io.translation_type == ACPI_SPARSE_TRANSLATION)
                 sparse = 1;
 
-        space_nr = new_space(addr->address_translation_offset, sparse);
+        space_nr = new_space(addr->translation_offset, sparse);
         if (space_nr == ~0)
                 goto free_name;
 
@@ -285,7 +285,7 @@ static __devinit acpi_status add_window(struct acpi_resource *res, void *data)
         if (addr.resource_type == ACPI_MEMORY_RANGE) {
                 flags = IORESOURCE_MEM;
                 root = &iomem_resource;
-                offset = addr.address_translation_offset;
+                offset = addr.translation_offset;
         } else if (addr.resource_type == ACPI_IO_RANGE) {
                 flags = IORESOURCE_IO;
                 root = &ioport_resource;
@@ -298,7 +298,7 @@ static __devinit acpi_status add_window(struct acpi_resource *res, void *data)
         window = &info->controller->window[info->controller->windows++];
         window->resource.name = info->name;
         window->resource.flags = flags;
-        window->resource.start = addr.min_address_range + offset;
+        window->resource.start = addr.minimum + offset;
         window->resource.end = window->resource.start + addr.address_length - 1;
         window->resource.child = NULL;
         window->offset = offset;
diff --git a/arch/ia64/sn/kernel/io_init.c b/arch/ia64/sn/kernel/io_init.c
index 00700f7e6837..6dbb7fca1c57 100644
--- a/arch/ia64/sn/kernel/io_init.c
+++ b/arch/ia64/sn/kernel/io_init.c
@@ -10,6 +10,7 @@
 #include <linux/nodemask.h>
 #include <asm/sn/types.h>
 #include <asm/sn/addrs.h>
+#include <asm/sn/sn_feature_sets.h>
 #include <asm/sn/geo.h>
 #include <asm/sn/io.h>
 #include <asm/sn/pcibr_provider.h>
@@ -173,8 +174,8 @@ sn_pcidev_info_get(struct pci_dev *dev)
  */
 static u8 war_implemented = 0;
 
-static void sn_device_fixup_war(u64 nasid, u64 widget, int device,
-                                struct sn_flush_device_common *common)
+static s64 sn_device_fixup_war(u64 nasid, u64 widget, int device,
+                               struct sn_flush_device_common *common)
 {
         struct sn_flush_device_war *war_list;
         struct sn_flush_device_war *dev_entry;
@@ -198,8 +199,9 @@ static void sn_device_fixup_war(u64 nasid, u64 widget, int device,
 
         dev_entry = war_list + device;
         memcpy(common,dev_entry, sizeof(*common));
-
         kfree(war_list);
+
+        return isrv.status;
 }
 
 /*
@@ -279,23 +281,21 @@ static void sn_fixup_ionodes(void)
                                 memset(dev_entry->common, 0x0, sizeof(struct
                                                        sn_flush_device_common));
 
-                                status = sal_get_device_dmaflush_list(nasid,
-                                                                        widget,
-                                                                        device,
+                                if (sn_prom_feature_available(
+                                                       PRF_DEVICE_FLUSH_LIST))
+                                        status = sal_get_device_dmaflush_list(
+                                                                          nasid,
+                                                                         widget,
+                                                                         device,
                                                       (u64)(dev_entry->common));
-                                if (status) {
-                                        if (sn_sal_rev() < 0x0450) {
-                                                /* shortlived WAR for older
-                                                 * PROM images
-                                                 */
-                                                sn_device_fixup_war(nasid,
-                                                                    widget,
-                                                                    device,
+                                else
+                                        status = sn_device_fixup_war(nasid,
+                                                                     widget,
+                                                                     device,
                                                              dev_entry->common);
-                                        }
-                                        else
-                                                BUG();
-                                }
+                                if (status != SALRET_OK)
+                                        panic("SAL call failed: %s\n",
+                                              ia64_sal_strerror(status));
 
                                 spin_lock_init(&dev_entry->sfdl_flush_lock);
                         }
@@ -467,6 +467,13 @@ void sn_pci_fixup_slot(struct pci_dev *dev)
                 pcidev_info->pdi_sn_irq_info = NULL;
                 kfree(sn_irq_info);
         }
+
+        /*
+         * MSI currently not supported on altix.  Remove this when
+         * the MSI abstraction patches are integrated into the kernel
+         * (sometime after 2.6.16 releases)
+         */
+        dev->no_msi = 1;
 }
 
 /*
diff --git a/arch/ia64/sn/kernel/irq.c b/arch/ia64/sn/kernel/irq.c
index ec37084bdc17..928b4ac5e7de 100644
--- a/arch/ia64/sn/kernel/irq.c
+++ b/arch/ia64/sn/kernel/irq.c
@@ -86,7 +86,7 @@ static void sn_ack_irq(unsigned int irq)
               mask);
         __set_bit(irq, (volatile void *)pda->sn_in_service_ivecs);
 
-        move_irq(irq);
+        move_native_irq(irq);
 }
 
 static void sn_end_irq(unsigned int irq)
diff --git a/arch/ia64/sn/kernel/sn2/sn2_smp.c b/arch/ia64/sn/kernel/sn2/sn2_smp.c
index 471bbaa65d1b..f153a4c35c70 100644
--- a/arch/ia64/sn/kernel/sn2/sn2_smp.c
+++ b/arch/ia64/sn/kernel/sn2/sn2_smp.c
@@ -5,7 +5,7 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (C) 2000-2005 Silicon Graphics, Inc. All rights reserved.
+ * Copyright (C) 2000-2006 Silicon Graphics, Inc. All rights reserved.
  */
 
 #include <linux/init.h>
@@ -46,104 +46,28 @@ DECLARE_PER_CPU(struct ptc_stats, ptcstats);
 
 static  __cacheline_aligned DEFINE_SPINLOCK(sn2_global_ptc_lock);
 
-void sn2_ptc_deadlock_recovery(short *, short, int, volatile unsigned long *, unsigned long data0,
-        volatile unsigned long *, unsigned long data1);
+void sn2_ptc_deadlock_recovery(short *, short, short, int, volatile unsigned long *, unsigned long,
+        volatile unsigned long *, unsigned long);
 
-#ifdef DEBUG_PTC
 /*
- * ptctest:
- *
- *      xyz - 3 digit hex number:
- *              x - Force PTC purges to use shub:
- *                      0 - no force
- *                      1 - force
- *              y - interupt enable
- *                      0 - disable interrupts
- *                      1 - leave interuupts enabled
- *              z - type of lock:
- *                      0 - global lock
- *                      1 - node local lock
- *                      2 - no lock
- *
- *      Note: on shub1, only ptctest == 0 is supported. Don't try other values!
+ * Note: some is the following is captured here to make degugging easier
+ * (the macros make more sense if you see the debug patch - not posted)
  */
-
-static unsigned int sn2_ptctest = 0;
-
-static int __init ptc_test(char *str)
-{
-        get_option(&str, &sn2_ptctest);
-        return 1;
-}
-__setup("ptctest=", ptc_test);
-
-static inline int ptc_lock(unsigned long *flagp)
-{
-        unsigned long opt = sn2_ptctest & 255;
-
-        switch (opt) {
-        case 0x00:
-                spin_lock_irqsave(&sn2_global_ptc_lock, *flagp);
-                break;
-        case 0x01:
-                spin_lock_irqsave(&sn_nodepda->ptc_lock, *flagp);
-                break;
-        case 0x02:
-                local_irq_save(*flagp);
-                break;
-        case 0x10:
-                spin_lock(&sn2_global_ptc_lock);
-                break;
-        case 0x11:
-                spin_lock(&sn_nodepda->ptc_lock);
-                break;
-        case 0x12:
-                break;
-        default:
-                BUG();
-        }
-        return opt;
-}
-
-static inline void ptc_unlock(unsigned long flags, int opt)
-{
-        switch (opt) {
-        case 0x00:
-                spin_unlock_irqrestore(&sn2_global_ptc_lock, flags);
-                break;
-        case 0x01:
-                spin_unlock_irqrestore(&sn_nodepda->ptc_lock, flags);
-                break;
-        case 0x02:
-                local_irq_restore(flags);
-                break;
-        case 0x10:
-                spin_unlock(&sn2_global_ptc_lock);
-                break;
-        case 0x11:
-                spin_unlock(&sn_nodepda->ptc_lock);
-                break;
-        case 0x12:
-                break;
-        default:
-                BUG();
-        }
-}
-#else
-
 #define sn2_ptctest     0
+#define local_node_uses_ptc_ga(sh1)     ((sh1) ? 1 : 0)
+#define max_active_pio(sh1)             ((sh1) ? 32 : 7)
+#define reset_max_active_on_deadlock()  1
+#define PTC_LOCK(sh1)                   ((sh1) ? &sn2_global_ptc_lock : &sn_nodepda->ptc_lock)
 
-static inline int ptc_lock(unsigned long *flagp)
+static inline void ptc_lock(int sh1, unsigned long *flagp)
 {
-        spin_lock_irqsave(&sn2_global_ptc_lock, *flagp);
-        return 0;
+        spin_lock_irqsave(PTC_LOCK(sh1), *flagp);
 }
 
-static inline void ptc_unlock(unsigned long flags, int opt)
+static inline void ptc_unlock(int sh1, unsigned long flags)
 {
-        spin_unlock_irqrestore(&sn2_global_ptc_lock, flags);
+        spin_unlock_irqrestore(PTC_LOCK(sh1), flags);
 }
-#endif
 
 struct ptc_stats {
         unsigned long ptc_l;
@@ -151,27 +75,30 @@ struct ptc_stats {
         unsigned long shub_ptc_flushes;
         unsigned long nodes_flushed;
         unsigned long deadlocks;
+        unsigned long deadlocks2;
         unsigned long lock_itc_clocks;
         unsigned long shub_itc_clocks;
         unsigned long shub_itc_clocks_max;
+        unsigned long shub_ptc_flushes_not_my_mm;
 };
 
 static inline unsigned long wait_piowc(void)
 {
-        volatile unsigned long *piows, zeroval;
-        unsigned long ws;
+        volatile unsigned long *piows;
+        unsigned long zeroval, ws;
 
         piows = pda->pio_write_status_addr;
         zeroval = pda->pio_write_status_val;
         do {
                 cpu_relax();
         } while (((ws = *piows) & SH_PIO_WRITE_STATUS_PENDING_WRITE_COUNT_MASK) != zeroval);
-        return ws;
+        return (ws & SH_PIO_WRITE_STATUS_WRITE_DEADLOCK_MASK) != 0;
 }
 
 void sn_tlb_migrate_finish(struct mm_struct *mm)
 {
-        if (mm == current->mm)
+        /* flush_tlb_mm is inefficient if more than 1 users of mm */
+        if (mm == current->mm && mm && atomic_read(&mm->mm_users) == 1)
                 flush_tlb_mm(mm);
 }
 
@@ -201,12 +128,14 @@ void
 sn2_global_tlb_purge(struct mm_struct *mm, unsigned long start,
                      unsigned long end, unsigned long nbits)
 {
-        int i, opt, shub1, cnode, mynasid, cpu, lcpu = 0, nasid, flushed = 0;
-        int mymm = (mm == current->active_mm && current->mm);
+        int i, ibegin, shub1, cnode, mynasid, cpu, lcpu = 0, nasid;
+        int mymm = (mm == current->active_mm && mm == current->mm);
+        int use_cpu_ptcga;
         volatile unsigned long *ptc0, *ptc1;
-        unsigned long itc, itc2, flags, data0 = 0, data1 = 0, rr_value;
+        unsigned long itc, itc2, flags, data0 = 0, data1 = 0, rr_value, old_rr = 0;
         short nasids[MAX_NUMNODES], nix;
         nodemask_t nodes_flushed;
+        int active, max_active, deadlock;
 
         nodes_clear(nodes_flushed);
         i = 0;
@@ -267,41 +196,56 @@ sn2_global_tlb_purge(struct mm_struct *mm, unsigned long start,
         
 
         mynasid = get_nasid();
+        use_cpu_ptcga = local_node_uses_ptc_ga(shub1);
+        max_active = max_active_pio(shub1);
 
         itc = ia64_get_itc();
-        opt = ptc_lock(&flags);
+        ptc_lock(shub1, &flags);
         itc2 = ia64_get_itc();
+
         __get_cpu_var(ptcstats).lock_itc_clocks += itc2 - itc;
         __get_cpu_var(ptcstats).shub_ptc_flushes++;
         __get_cpu_var(ptcstats).nodes_flushed += nix;
+        if (!mymm)
+                 __get_cpu_var(ptcstats).shub_ptc_flushes_not_my_mm++;
 
+        if (use_cpu_ptcga && !mymm) {
+                old_rr = ia64_get_rr(start);
+                ia64_set_rr(start, (old_rr & 0xff) | (rr_value << 8));
+                ia64_srlz_d();
+        }
+
+        wait_piowc();
         do {
                 if (shub1)
                         data1 = start | (1UL << SH1_PTC_1_START_SHFT);
                 else
                         data0 = (data0 & ~SH2_PTC_ADDR_MASK) | (start & SH2_PTC_ADDR_MASK);
-                for (i = 0; i < nix; i++) {
+                deadlock = 0;
+                active = 0;
+                for (ibegin = 0, i = 0; i < nix; i++) {
                         nasid = nasids[i];
-                        if ((!(sn2_ptctest & 3)) && unlikely(nasid == mynasid && mymm)) {
+                        if (use_cpu_ptcga && unlikely(nasid == mynasid)) {
                                 ia64_ptcga(start, nbits << 2);
                                 ia64_srlz_i();
                         } else {
                                 ptc0 = CHANGE_NASID(nasid, ptc0);
                                 if (ptc1)
                                         ptc1 = CHANGE_NASID(nasid, ptc1);
-                                pio_atomic_phys_write_mmrs(ptc0, data0, ptc1,
-                                                           data1);
-                                flushed = 1;
+                                pio_atomic_phys_write_mmrs(ptc0, data0, ptc1, data1);
+                                active++;
+                        }
+                        if (active >= max_active || i == (nix - 1)) {
+                                if ((deadlock = wait_piowc())) {
+                                        sn2_ptc_deadlock_recovery(nasids, ibegin, i, mynasid, ptc0, data0, ptc1, data1);
+                                        if (reset_max_active_on_deadlock())
+                                                max_active = 1;
+                                }
+                                active = 0;
+                                ibegin = i + 1;
                         }
                 }
-                if (flushed
-                    && (wait_piowc() &
-                                (SH_PIO_WRITE_STATUS_WRITE_DEADLOCK_MASK))) {
-                        sn2_ptc_deadlock_recovery(nasids, nix, mynasid, ptc0, data0, ptc1, data1);
-                }
-
                 start += (1UL << nbits);
-
         } while (start < end);
 
         itc2 = ia64_get_itc() - itc2;
@@ -309,7 +253,12 @@ sn2_global_tlb_purge(struct mm_struct *mm, unsigned long start,
         if (itc2 > __get_cpu_var(ptcstats).shub_itc_clocks_max)
                 __get_cpu_var(ptcstats).shub_itc_clocks_max = itc2;
 
-        ptc_unlock(flags, opt);
+        if (old_rr) {
+                ia64_set_rr(start, old_rr);
+                ia64_srlz_d();
+        }
+
+        ptc_unlock(shub1, flags);
 
         preempt_enable();
 }
@@ -321,27 +270,30 @@ sn2_global_tlb_purge(struct mm_struct *mm, unsigned long start,
  * TLB flush transaction.  The recovery sequence is somewhat tricky & is
  * coded in assembly language.
  */
-void sn2_ptc_deadlock_recovery(short *nasids, short nix, int mynasid, volatile unsigned long *ptc0, unsigned long data0,
+void sn2_ptc_deadlock_recovery(short *nasids, short ib, short ie, int mynasid, volatile unsigned long *ptc0, unsigned long data0,
         volatile unsigned long *ptc1, unsigned long data1)
 {
-        extern void sn2_ptc_deadlock_recovery_core(volatile unsigned long *, unsigned long,
+        extern unsigned long sn2_ptc_deadlock_recovery_core(volatile unsigned long *, unsigned long,
                 volatile unsigned long *, unsigned long, volatile unsigned long *, unsigned long);
         short nasid, i;
-        unsigned long *piows, zeroval;
+        unsigned long *piows, zeroval, n;
 
         __get_cpu_var(ptcstats).deadlocks++;
 
         piows = (unsigned long *) pda->pio_write_status_addr;
         zeroval = pda->pio_write_status_val;
 
-        for (i=0; i < nix; i++) {
+
+        for (i=ib; i <= ie; i++) {
                 nasid = nasids[i];
-                if (!(sn2_ptctest & 3) && nasid == mynasid)
+                if (local_node_uses_ptc_ga(is_shub1()) && nasid == mynasid)
                         continue;
                 ptc0 = CHANGE_NASID(nasid, ptc0);
                 if (ptc1)
                         ptc1 = CHANGE_NASID(nasid, ptc1);
-                sn2_ptc_deadlock_recovery_core(ptc0, data0, ptc1, data1, piows, zeroval);
+
+                n = sn2_ptc_deadlock_recovery_core(ptc0, data0, ptc1, data1, piows, zeroval);
+                __get_cpu_var(ptcstats).deadlocks2 += n;
         }
 
 }
@@ -452,20 +404,22 @@ static int sn2_ptc_seq_show(struct seq_file *file, void *data)
         cpu = *(loff_t *) data;
 
         if (!cpu) {
-                seq_printf(file, "# ptc_l change_rid shub_ptc_flushes shub_nodes_flushed deadlocks lock_nsec shub_nsec shub_nsec_max\n");
+                seq_printf(file,
+                           "# cpu ptc_l newrid ptc_flushes nodes_flushed deadlocks lock_nsec shub_nsec shub_nsec_max not_my_mm deadlock2\n");
                 seq_printf(file, "# ptctest %d\n", sn2_ptctest);
         }
 
         if (cpu < NR_CPUS && cpu_online(cpu)) {
                 stat = &per_cpu(ptcstats, cpu);
-                seq_printf(file, "cpu %d %ld %ld %ld %ld %ld %ld %ld %ld\n", cpu, stat->ptc_l,
+                seq_printf(file, "cpu %d %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld\n", cpu, stat->ptc_l,
                                 stat->change_rid, stat->shub_ptc_flushes, stat->nodes_flushed,
                                 stat->deadlocks,
                                 1000 * stat->lock_itc_clocks / per_cpu(cpu_info, cpu).cyc_per_usec,
                                 1000 * stat->shub_itc_clocks / per_cpu(cpu_info, cpu).cyc_per_usec,
-                                1000 * stat->shub_itc_clocks_max / per_cpu(cpu_info, cpu).cyc_per_usec);
+                                1000 * stat->shub_itc_clocks_max / per_cpu(cpu_info, cpu).cyc_per_usec,
+                                stat->shub_ptc_flushes_not_my_mm,
+                                stat->deadlocks2);
         }
-
         return 0;
 }
 
@@ -476,7 +430,7 @@ static struct seq_operations sn2_ptc_seq_ops = {
         .show = sn2_ptc_seq_show
 };
 
-int sn2_ptc_proc_open(struct inode *inode, struct file *file)
+static int sn2_ptc_proc_open(struct inode *inode, struct file *file)
 {
         return seq_open(file, &sn2_ptc_seq_ops);
 }
diff --git a/arch/ia64/sn/kernel/xpc_channel.c b/arch/ia64/sn/kernel/xpc_channel.c
index 8d950c778bb6..36e5437a0fb6 100644
--- a/arch/ia64/sn/kernel/xpc_channel.c
+++ b/arch/ia64/sn/kernel/xpc_channel.c
@@ -447,7 +447,7 @@ xpc_allocate_local_msgqueue(struct xpc_channel *ch)
 
                 nbytes = nentries * ch->msg_size;
                 ch->local_msgqueue = xpc_kmalloc_cacheline_aligned(nbytes,
-                                                (GFP_KERNEL | GFP_DMA),
+                                                GFP_KERNEL,
                                                 &ch->local_msgqueue_base);
                 if (ch->local_msgqueue == NULL) {
                         continue;
@@ -455,7 +455,7 @@ xpc_allocate_local_msgqueue(struct xpc_channel *ch)
                 memset(ch->local_msgqueue, 0, nbytes);
 
                 nbytes = nentries * sizeof(struct xpc_notify);
-                ch->notify_queue = kmalloc(nbytes, (GFP_KERNEL | GFP_DMA));
+                ch->notify_queue = kmalloc(nbytes, GFP_KERNEL);
                 if (ch->notify_queue == NULL) {
                         kfree(ch->local_msgqueue_base);
                         ch->local_msgqueue = NULL;
@@ -502,7 +502,7 @@ xpc_allocate_remote_msgqueue(struct xpc_channel *ch)
 
                 nbytes = nentries * ch->msg_size;
                 ch->remote_msgqueue = xpc_kmalloc_cacheline_aligned(nbytes,
-                                                (GFP_KERNEL | GFP_DMA),
+                                                GFP_KERNEL,
                                                 &ch->remote_msgqueue_base);
                 if (ch->remote_msgqueue == NULL) {
                         continue;
diff --git a/arch/ia64/sn/pci/pci_dma.c b/arch/ia64/sn/pci/pci_dma.c
index 9bf9f23b9a1f..5a36292388eb 100644
--- a/arch/ia64/sn/pci/pci_dma.c
+++ b/arch/ia64/sn/pci/pci_dma.c
@@ -90,14 +90,14 @@ void *sn_dma_alloc_coherent(struct device *dev, size_t size,
          */
         node = pcibus_to_node(pdev->bus);
         if (likely(node >=0)) {
-                struct page *p = alloc_pages_node(node, GFP_ATOMIC, get_order(size));
+                struct page *p = alloc_pages_node(node, flags, get_order(size));
 
                 if (likely(p))
                         cpuaddr = page_address(p);
                 else
                         return NULL;
         } else
-                cpuaddr = (void *)__get_free_pages(GFP_ATOMIC, get_order(size));
+                cpuaddr = (void *)__get_free_pages(flags, get_order(size));
 
         if (unlikely(!cpuaddr))
                 return NULL;