13 files changed, 205 insertions, 107 deletions

diff --git a/arch/ia64/Kconfig b/arch/ia64/Kconfig
index fbb25b00629b..18318749884b 100644
--- a/arch/ia64/Kconfig
+++ b/arch/ia64/Kconfig
@@ -449,6 +449,8 @@ config PCI_DOMAINS
         bool
         default PCI
 
+source "drivers/pci/pcie/Kconfig"
+
 source "drivers/pci/Kconfig"
 
 source "drivers/pci/hotplug/Kconfig"
diff --git a/arch/ia64/Makefile b/arch/ia64/Makefile
index 80ea7506fa1a..21033ed83307 100644
--- a/arch/ia64/Makefile
+++ b/arch/ia64/Makefile
@@ -71,6 +71,8 @@ all: compressed unwcheck
 
 compressed: vmlinux.gz
 
+vmlinuz: vmlinux.gz
+
 vmlinux.gz: vmlinux
         $(Q)$(MAKE) $(build)=$(boot) $@
 
diff --git a/arch/ia64/kernel/asm-offsets.c b/arch/ia64/kernel/asm-offsets.c
index 77225659e968..16e7b6600ae6 100644
--- a/arch/ia64/kernel/asm-offsets.c
+++ b/arch/ia64/kernel/asm-offsets.c
@@ -217,16 +217,24 @@ void foo(void)
         DEFINE(IA64_MCA_CPU_INIT_STACK_OFFSET,
                offsetof (struct ia64_mca_cpu, init_stack));
         BLANK();
-        DEFINE(IA64_SAL_OS_STATE_COMMON_OFFSET,
-               offsetof (struct ia64_sal_os_state, sal_ra));
         DEFINE(IA64_SAL_OS_STATE_OS_GP_OFFSET,
                offsetof (struct ia64_sal_os_state, os_gp));
-        DEFINE(IA64_SAL_OS_STATE_PAL_MIN_STATE_OFFSET,
-               offsetof (struct ia64_sal_os_state, pal_min_state));
         DEFINE(IA64_SAL_OS_STATE_PROC_STATE_PARAM_OFFSET,
                offsetof (struct ia64_sal_os_state, proc_state_param));
+        DEFINE(IA64_SAL_OS_STATE_SAL_RA_OFFSET,
+               offsetof (struct ia64_sal_os_state, sal_ra));
+        DEFINE(IA64_SAL_OS_STATE_SAL_GP_OFFSET,
+               offsetof (struct ia64_sal_os_state, sal_gp));
+        DEFINE(IA64_SAL_OS_STATE_PAL_MIN_STATE_OFFSET,
+               offsetof (struct ia64_sal_os_state, pal_min_state));
+        DEFINE(IA64_SAL_OS_STATE_OS_STATUS_OFFSET,
+               offsetof (struct ia64_sal_os_state, os_status));
+        DEFINE(IA64_SAL_OS_STATE_CONTEXT_OFFSET,
+               offsetof (struct ia64_sal_os_state, context));
         DEFINE(IA64_SAL_OS_STATE_SIZE,
                sizeof (struct ia64_sal_os_state));
+        BLANK();
+
         DEFINE(IA64_PMSA_GR_OFFSET,
                offsetof (struct pal_min_state_area_s, pmsa_gr));
         DEFINE(IA64_PMSA_BANK1_GR_OFFSET,
diff --git a/arch/ia64/kernel/efi.c b/arch/ia64/kernel/efi.c
index 12cfedce73b1..c33d0ba7e300 100644
--- a/arch/ia64/kernel/efi.c
+++ b/arch/ia64/kernel/efi.c
@@ -8,6 +8,8 @@
  * Copyright (C) 1999-2003 Hewlett-Packard Co.
  *      David Mosberger-Tang <davidm@hpl.hp.com>
  *      Stephane Eranian <eranian@hpl.hp.com>
+ * (c) Copyright 2006 Hewlett-Packard Development Company, L.P.
+ *      Bjorn Helgaas <bjorn.helgaas@hp.com>
  *
  * All EFI Runtime Services are not implemented yet as EFI only
  * supports physical mode addressing on SoftSDV. This is to be fixed
@@ -622,28 +624,20 @@ efi_get_iobase (void)
         return 0;
 }
 
-static efi_memory_desc_t *
-efi_memory_descriptor (unsigned long phys_addr)
+static struct kern_memdesc *
+kern_memory_descriptor (unsigned long phys_addr)
 {
-        void *efi_map_start, *efi_map_end, *p;
-        efi_memory_desc_t *md;
-        u64 efi_desc_size;
-
-        efi_map_start = __va(ia64_boot_param->efi_memmap);
-        efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
-        efi_desc_size = ia64_boot_param->efi_memdesc_size;
+        struct kern_memdesc *md;
 
-        for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
-                md = p;
-
-                if (phys_addr - md->phys_addr < (md->num_pages << EFI_PAGE_SHIFT))
+        for (md = kern_memmap; md->start != ~0UL; md++) {
+                if (phys_addr - md->start < (md->num_pages << EFI_PAGE_SHIFT))
                          return md;
         }
         return 0;
 }
 
-static int
-efi_memmap_has_mmio (void)
+static efi_memory_desc_t *
+efi_memory_descriptor (unsigned long phys_addr)
 {
         void *efi_map_start, *efi_map_end, *p;
         efi_memory_desc_t *md;
@@ -656,8 +650,8 @@ efi_memmap_has_mmio (void)
         for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
                 md = p;
 
-                if (md->type == EFI_MEMORY_MAPPED_IO)
-                        return 1;
+                if (phys_addr - md->phys_addr < (md->num_pages << EFI_PAGE_SHIFT))
+                         return md;
         }
         return 0;
 }
@@ -683,71 +677,125 @@ efi_mem_attributes (unsigned long phys_addr)
 }
 EXPORT_SYMBOL(efi_mem_attributes);
 
-/*
- * Determines whether the memory at phys_addr supports the desired
- * attribute (WB, UC, etc).  If this returns 1, the caller can safely
- * access size bytes at phys_addr with the specified attribute.
- */
-int
-efi_mem_attribute_range (unsigned long phys_addr, unsigned long size, u64 attr)
+u64
+efi_mem_attribute (unsigned long phys_addr, unsigned long size)
 {
         unsigned long end = phys_addr + size;
         efi_memory_desc_t *md = efi_memory_descriptor(phys_addr);
+        u64 attr;
+
+        if (!md)
+                return 0;
+
+        /*
+         * EFI_MEMORY_RUNTIME is not a memory attribute; it just tells
+         * the kernel that firmware needs this region mapped.
+         */
+        attr = md->attribute & ~EFI_MEMORY_RUNTIME;
+        do {
+                unsigned long md_end = efi_md_end(md);
+
+                if (end <= md_end)
+                        return attr;
+
+                md = efi_memory_descriptor(md_end);
+                if (!md || (md->attribute & ~EFI_MEMORY_RUNTIME) != attr)
+                        return 0;
+        } while (md);
+        return 0;
+}
+
+u64
+kern_mem_attribute (unsigned long phys_addr, unsigned long size)
+{
+        unsigned long end = phys_addr + size;
+        struct kern_memdesc *md;
+        u64 attr;
 
         /*
-         * Some firmware doesn't report MMIO regions in the EFI memory
-         * map.  The Intel BigSur (a.k.a. HP i2000) has this problem.
-         * On those platforms, we have to assume UC is valid everywhere.
+         * This is a hack for ioremap calls before we set up kern_memmap.
+         * Maybe we should do efi_memmap_init() earlier instead.
          */
-        if (!md || (md->attribute & attr) != attr) {
-                if (attr == EFI_MEMORY_UC && !efi_memmap_has_mmio())
-                        return 1;
+        if (!kern_memmap) {
+                attr = efi_mem_attribute(phys_addr, size);
+                if (attr & EFI_MEMORY_WB)
+                        return EFI_MEMORY_WB;
                 return 0;
         }
 
+        md = kern_memory_descriptor(phys_addr);
+        if (!md)
+                return 0;
+
+        attr = md->attribute;
         do {
-                unsigned long md_end = efi_md_end(md);
+                unsigned long md_end = kmd_end(md);
 
                 if (end <= md_end)
-                        return 1;
+                        return attr;
 
-                md = efi_memory_descriptor(md_end);
-                if (!md || (md->attribute & attr) != attr)
+                md = kern_memory_descriptor(md_end);
+                if (!md || md->attribute != attr)
                         return 0;
         } while (md);
         return 0;
 }
+EXPORT_SYMBOL(kern_mem_attribute);
 
-/*
- * For /dev/mem, we only allow read & write system calls to access
- * write-back memory, because read & write don't allow the user to
- * control access size.
- */
 int
 valid_phys_addr_range (unsigned long phys_addr, unsigned long size)
 {
-        return efi_mem_attribute_range(phys_addr, size, EFI_MEMORY_WB);
+        u64 attr;
+
+        /*
+         * /dev/mem reads and writes use copy_to_user(), which implicitly
+         * uses a granule-sized kernel identity mapping.  It's really
+         * only safe to do this for regions in kern_memmap.  For more
+         * details, see Documentation/ia64/aliasing.txt.
+         */
+        attr = kern_mem_attribute(phys_addr, size);
+        if (attr & EFI_MEMORY_WB || attr & EFI_MEMORY_UC)
+                return 1;
+        return 0;
 }
 
-/*
- * We allow mmap of anything in the EFI memory map that supports
- * either write-back or uncacheable access.  For uncacheable regions,
- * the supported access sizes are system-dependent, and the user is
- * responsible for using the correct size.
- *
- * Note that this doesn't currently allow access to hot-added memory,
- * because that doesn't appear in the boot-time EFI memory map.
- */
 int
 valid_mmap_phys_addr_range (unsigned long phys_addr, unsigned long size)
 {
-        if (efi_mem_attribute_range(phys_addr, size, EFI_MEMORY_WB))
-                return 1;
+        /*
+         * MMIO regions are often missing from the EFI memory map.
+         * We must allow mmap of them for programs like X, so we
+         * currently can't do any useful validation.
+         */
+        return 1;
+}
 
-        if (efi_mem_attribute_range(phys_addr, size, EFI_MEMORY_UC))
-                return 1;
+pgprot_t
+phys_mem_access_prot(struct file *file, unsigned long pfn, unsigned long size,
+                     pgprot_t vma_prot)
+{
+        unsigned long phys_addr = pfn << PAGE_SHIFT;
+        u64 attr;
 
-        return 0;
+        /*
+         * For /dev/mem mmap, we use user mappings, but if the region is
+         * in kern_memmap (and hence may be covered by a kernel mapping),
+         * we must use the same attribute as the kernel mapping.
+         */
+        attr = kern_mem_attribute(phys_addr, size);
+        if (attr & EFI_MEMORY_WB)
+                return pgprot_cacheable(vma_prot);
+        else if (attr & EFI_MEMORY_UC)
+                return pgprot_noncached(vma_prot);
+
+        /*
+         * Some chipsets don't support UC access to memory.  If
+         * WB is supported, we prefer that.
+         */
+        if (efi_mem_attribute(phys_addr, size) & EFI_MEMORY_WB)
+                return pgprot_cacheable(vma_prot);
+
+        return pgprot_noncached(vma_prot);
 }
 
 int __init
diff --git a/arch/ia64/kernel/efi_stub.S b/arch/ia64/kernel/efi_stub.S
index 5a7fe70212a9..a56e161d7515 100644
--- a/arch/ia64/kernel/efi_stub.S
+++ b/arch/ia64/kernel/efi_stub.S
@@ -61,7 +61,7 @@ GLOBAL_ENTRY(efi_call_phys)
         or loc3=loc3,r17
         mov b6=r2
         ;;
-        andcm r16=loc3,r16              // get psr with IT, DT, and RT bits cleared
+        andcm r16=loc3,r16      // get psr with IT, DT, and RT bits cleared
         br.call.sptk.many rp=ia64_switch_mode_phys
 .ret0:  mov out4=in5
         mov out0=in1
diff --git a/arch/ia64/kernel/entry.h b/arch/ia64/kernel/entry.h
index 78eeb0793419..ebc3dfb88826 100644
--- a/arch/ia64/kernel/entry.h
+++ b/arch/ia64/kernel/entry.h
@@ -23,6 +23,7 @@
 
 #define PT(f)           (IA64_PT_REGS_##f##_OFFSET)
 #define SW(f)           (IA64_SWITCH_STACK_##f##_OFFSET)
+#define SOS(f)          (IA64_SAL_OS_STATE_##f##_OFFSET)
 
 #define PT_REGS_SAVES(off)                      \
         .unwabi 3, 'i';                         \
diff --git a/arch/ia64/kernel/mca_asm.S b/arch/ia64/kernel/mca_asm.S
index 6dff024cd62b..c1bd1feffab0 100644
--- a/arch/ia64/kernel/mca_asm.S
+++ b/arch/ia64/kernel/mca_asm.S
@@ -159,7 +159,7 @@ ia64_os_mca_spin:
         GET_IA64_MCA_DATA(r2)
         // Using MCA stack, struct ia64_sal_os_state, variable proc_state_param
         ;;
-        add r3=IA64_MCA_CPU_MCA_STACK_OFFSET+MCA_SOS_OFFSET+IA64_SAL_OS_STATE_PROC_STATE_PARAM_OFFSET, r2
+        add r3=IA64_MCA_CPU_MCA_STACK_OFFSET+MCA_SOS_OFFSET+SOS(PROC_STATE_PARAM), r2
         ;;
         ld8 r18=[r3]                            // Get processor state parameter on existing PALE_CHECK.
         ;;
@@ -479,9 +479,11 @@ ia64_state_save:
         st8 [temp2]=r11,16      // rv_rc
         mov r11=cr.iipa
         ;;
-        st8 [temp1]=r18,16      // proc_state_param
-        st8 [temp2]=r19,16      // monarch
+        st8 [temp1]=r18         // proc_state_param
+        st8 [temp2]=r19         // monarch
         mov r6=IA64_KR(CURRENT)
+        add temp1=SOS(SAL_RA), regs
+        add temp2=SOS(SAL_GP), regs
         ;;
         st8 [temp1]=r12,16      // sal_ra
         st8 [temp2]=r10,16      // sal_gp
@@ -503,12 +505,14 @@ ia64_state_save:
         st8 [temp2]=r11,16      // cr.iipa
         mov r12=cr.iim
         ;;
-        st8 [temp1]=r12,16      // cr.iim
+        st8 [temp1]=r12         // cr.iim
 (p1)    mov r12=IA64_MCA_COLD_BOOT
 (p2)    mov r12=IA64_INIT_WARM_BOOT
         mov r6=cr.iha
+        add temp1=SOS(OS_STATUS), regs
         ;;
-        st8 [temp2]=r6,16       // cr.iha
+        st8 [temp2]=r6          // cr.iha
+        add temp2=SOS(CONTEXT), regs
         st8 [temp1]=r12         // os_status, default is cold boot
         mov r6=IA64_MCA_SAME_CONTEXT
         ;;
@@ -820,8 +824,8 @@ ia64_state_restore:
         // Restore the SAL to OS state. The previous code left regs at pt_regs.
         add regs=MCA_SOS_OFFSET-MCA_PT_REGS_OFFSET, regs
         ;;
-        add temp1=IA64_SAL_OS_STATE_COMMON_OFFSET, regs
-        add temp2=IA64_SAL_OS_STATE_COMMON_OFFSET+8, regs
+        add temp1=SOS(SAL_RA), regs
+        add temp2=SOS(SAL_GP), regs
         ;;
         ld8 r12=[temp1],16      // sal_ra
         ld8 r9=[temp2],16       // sal_gp
@@ -842,8 +846,10 @@ ia64_state_restore:
         ;;
         mov cr.itir=temp3
         mov cr.iipa=temp4
-        ld8 temp3=[temp1],16    // cr.iim
-        ld8 temp4=[temp2],16    // cr.iha
+        ld8 temp3=[temp1]       // cr.iim
+        ld8 temp4=[temp2]               // cr.iha
+        add temp1=SOS(OS_STATUS), regs
+        add temp2=SOS(CONTEXT), regs
         ;;
         mov cr.iim=temp3
         mov cr.iha=temp4
@@ -916,7 +922,7 @@ ia64_state_restore:
 
 ia64_new_stack:
         add regs=MCA_PT_REGS_OFFSET, r3
-        add temp2=MCA_SOS_OFFSET+IA64_SAL_OS_STATE_PAL_MIN_STATE_OFFSET, r3
+        add temp2=MCA_SOS_OFFSET+SOS(PAL_MIN_STATE), r3
         mov b0=r2                       // save return address
         GET_IA64_MCA_DATA(temp1)
         invala
@@ -1020,7 +1026,7 @@ ia64_old_stack:
 
 ia64_set_kernel_registers:
         add temp3=MCA_SP_OFFSET, r3
-        add temp4=MCA_SOS_OFFSET+IA64_SAL_OS_STATE_OS_GP_OFFSET, r3
+        add temp4=MCA_SOS_OFFSET+SOS(OS_GP), r3
         mov b0=r2               // save return address
         GET_IA64_MCA_DATA(temp1)
         ;;
diff --git a/arch/ia64/kernel/sal.c b/arch/ia64/kernel/sal.c
index 056f7a6eedc7..77fa65903d94 100644
--- a/arch/ia64/kernel/sal.c
+++ b/arch/ia64/kernel/sal.c
@@ -227,7 +227,7 @@ static int sal_cache_flush_drops_interrupts;
 static void __init
 check_sal_cache_flush (void)
 {
-        unsigned long flags, itv;
+        unsigned long flags;
         int cpu;
         u64 vector;
 
@@ -238,9 +238,6 @@ check_sal_cache_flush (void)
          * 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);
 
@@ -260,7 +257,6 @@ check_sal_cache_flush (void)
                 ia64_eoi();
         }
 
-        ia64_set_itv(itv);
         local_irq_restore(flags);
         put_cpu();
 }
diff --git a/arch/ia64/kernel/setup.c b/arch/ia64/kernel/setup.c
index e4dfda1eb7dd..6dba2d63f24d 100644
--- a/arch/ia64/kernel/setup.c
+++ b/arch/ia64/kernel/setup.c
@@ -260,6 +260,7 @@ reserve_memory (void)
         n++;
 
         num_rsvd_regions = n;
+        BUG_ON(IA64_MAX_RSVD_REGIONS + 1 < n);
 
         sort_regions(rsvd_region, num_rsvd_regions);
 }
diff --git a/arch/ia64/mm/ioremap.c b/arch/ia64/mm/ioremap.c
index 643ccc6960ce..07bd02b6c372 100644
--- a/arch/ia64/mm/ioremap.c
+++ b/arch/ia64/mm/ioremap.c
@@ -11,6 +11,7 @@
 #include <linux/module.h>
 #include <linux/efi.h>
 #include <asm/io.h>
+#include <asm/meminit.h>
 
 static inline void __iomem *
 __ioremap (unsigned long offset, unsigned long size)
@@ -21,16 +22,29 @@ __ioremap (unsigned long offset, unsigned long size)
 void __iomem *
 ioremap (unsigned long offset, unsigned long size)
 {
-        if (efi_mem_attribute_range(offset, size, EFI_MEMORY_WB))
-                return phys_to_virt(offset);
+        u64 attr;
+        unsigned long gran_base, gran_size;
 
-        if (efi_mem_attribute_range(offset, size, EFI_MEMORY_UC))
+        /*
+         * For things in kern_memmap, we must use the same attribute
+         * as the rest of the kernel.  For more details, see
+         * Documentation/ia64/aliasing.txt.
+         */
+        attr = kern_mem_attribute(offset, size);
+        if (attr & EFI_MEMORY_WB)
+                return phys_to_virt(offset);
+        else if (attr & EFI_MEMORY_UC)
                 return __ioremap(offset, size);
 
         /*
-         * Someday this should check ACPI resources so we
-         * can do the right thing for hot-plugged regions.
+         * Some chipsets don't support UC access to memory.  If
+         * WB is supported for the whole granule, we prefer that.
          */
+        gran_base = GRANULEROUNDDOWN(offset);
+        gran_size = GRANULEROUNDUP(offset + size) - gran_base;
+        if (efi_mem_attribute(gran_base, gran_size) & EFI_MEMORY_WB)
+                return phys_to_virt(offset);
+
         return __ioremap(offset, size);
 }
 EXPORT_SYMBOL(ioremap);
@@ -38,6 +52,9 @@ EXPORT_SYMBOL(ioremap);
 void __iomem *
 ioremap_nocache (unsigned long offset, unsigned long size)
 {
+        if (kern_mem_attribute(offset, size) & EFI_MEMORY_WB)
+                return 0;
+
         return __ioremap(offset, size);
 }
 EXPORT_SYMBOL(ioremap_nocache);
diff --git a/arch/ia64/pci/pci.c b/arch/ia64/pci/pci.c
index cf7751b99d1c..61dd8608da4f 100644
--- a/arch/ia64/pci/pci.c
+++ b/arch/ia64/pci/pci.c
@@ -645,18 +645,31 @@ char *ia64_pci_get_legacy_mem(struct pci_bus *bus)
 int
 pci_mmap_legacy_page_range(struct pci_bus *bus, struct vm_area_struct *vma)
 {
+        unsigned long size = vma->vm_end - vma->vm_start;
+        pgprot_t prot;
         char *addr;
 
+        /*
+         * Avoid attribute aliasing.  See Documentation/ia64/aliasing.txt
+         * for more details.
+         */
+        if (!valid_mmap_phys_addr_range(vma->vm_pgoff << PAGE_SHIFT, size))
+                return -EINVAL;
+        prot = phys_mem_access_prot(NULL, vma->vm_pgoff, size,
+                                    vma->vm_page_prot);
+        if (pgprot_val(prot) != pgprot_val(pgprot_noncached(vma->vm_page_prot)))
+                return -EINVAL;
+
         addr = pci_get_legacy_mem(bus);
         if (IS_ERR(addr))
                 return PTR_ERR(addr);
 
         vma->vm_pgoff += (unsigned long)addr >> PAGE_SHIFT;
-        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+        vma->vm_page_prot = prot;
         vma->vm_flags |= (VM_SHM | VM_RESERVED | VM_IO);
 
         if (remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
-                            vma->vm_end - vma->vm_start, vma->vm_page_prot))
+                            size, vma->vm_page_prot))
                 return -EAGAIN;
 
         return 0;
diff --git a/arch/ia64/sn/kernel/sn2/sn_hwperf.c b/arch/ia64/sn/kernel/sn2/sn_hwperf.c
index 739c948dc504..9a8a29339d2d 100644
--- a/arch/ia64/sn/kernel/sn2/sn_hwperf.c
+++ b/arch/ia64/sn/kernel/sn2/sn_hwperf.c
@@ -51,6 +51,8 @@ static nasid_t sn_hwperf_master_nasid = INVALID_NASID;
 static int sn_hwperf_init(void);
 static DECLARE_MUTEX(sn_hwperf_init_mutex);
 
+#define cnode_possible(n)       ((n) < num_cnodes)
+
 static int sn_hwperf_enum_objects(int *nobj, struct sn_hwperf_object_info **ret)
 {
         int e;
@@ -127,14 +129,14 @@ static int sn_hwperf_geoid_to_cnode(char *location)
                 }
         }
 
-        return node_possible(cnode) ? cnode : -1;
+        return cnode_possible(cnode) ? cnode : -1;
 }
 
 static int sn_hwperf_obj_to_cnode(struct sn_hwperf_object_info * obj)
 {
         if (!SN_HWPERF_IS_NODE(obj) && !SN_HWPERF_IS_IONODE(obj))
                 BUG();
-        if (!obj->sn_hwp_this_part)
+        if (SN_HWPERF_FOREIGN(obj))
                 return -1;
         return sn_hwperf_geoid_to_cnode(obj->location);
 }
@@ -199,12 +201,12 @@ static void print_pci_topology(struct seq_file *s)
 
 static inline int sn_hwperf_has_cpus(cnodeid_t node)
 {
-        return node_online(node) && nr_cpus_node(node);
+        return node < MAX_NUMNODES && node_online(node) && nr_cpus_node(node);
 }
 
 static inline int sn_hwperf_has_mem(cnodeid_t node)
 {
-        return node_online(node) && NODE_DATA(node)->node_present_pages;
+        return node < MAX_NUMNODES && node_online(node) && NODE_DATA(node)->node_present_pages;
 }
 
 static struct sn_hwperf_object_info *
@@ -237,7 +239,7 @@ static int sn_hwperf_get_nearest_node_objdata(struct sn_hwperf_object_info *objb
         int found_mem = 0;
         int found_cpu = 0;
 
-        if (!node_possible(node))
+        if (!cnode_possible(node))
                 return -EINVAL;
 
         if (sn_hwperf_has_cpus(node)) {
@@ -442,7 +444,7 @@ static int sn_topology_show(struct seq_file *s, void *d)
         seq_printf(s, "%s %d %s %s asic %s", slabname, ordinal, obj->location,
                 obj->sn_hwp_this_part ? "local" : "shared", obj->name);
 
-        if (!SN_HWPERF_IS_NODE(obj) && !SN_HWPERF_IS_IONODE(obj))
+        if (ordinal < 0 || (!SN_HWPERF_IS_NODE(obj) && !SN_HWPERF_IS_IONODE(obj)))
                 seq_putc(s, '\n');
         else {
                 cnodeid_t near_mem = -1;
@@ -468,22 +470,24 @@ static int sn_topology_show(struct seq_file *s, void *d)
                 /*
                  * CPUs on this node, if any
                  */
-                cpumask = node_to_cpumask(ordinal);
-                for_each_online_cpu(i) {
-                        if (cpu_isset(i, cpumask)) {
-                                slice = 'a' + cpuid_to_slice(i);
-                                c = cpu_data(i);
-                                seq_printf(s, "cpu %d %s%c local"
-                                        " freq %luMHz, arch ia64",
-                                        i, obj->location, slice,
-                                        c->proc_freq / 1000000);
-                                for_each_online_cpu(j) {
-                                        seq_printf(s, j ? ":%d" : ", dist %d",
-                                                node_distance(
-                                                    cpu_to_node(i),
-                                                    cpu_to_node(j)));
+                if (!SN_HWPERF_IS_IONODE(obj)) {
+                        cpumask = node_to_cpumask(ordinal);
+                        for_each_online_cpu(i) {
+                                if (cpu_isset(i, cpumask)) {
+                                        slice = 'a' + cpuid_to_slice(i);
+                                        c = cpu_data(i);
+                                        seq_printf(s, "cpu %d %s%c local"
+                                                " freq %luMHz, arch ia64",
+                                                i, obj->location, slice,
+                                                c->proc_freq / 1000000);
+                                        for_each_online_cpu(j) {
+                                                seq_printf(s, j ? ":%d" : ", dist %d",
+                                                        node_distance(
+                                                        cpu_to_node(i),
+                                                        cpu_to_node(j)));
+                                        }
+                                        seq_putc(s, '\n');
                                 }
-                                seq_putc(s, '\n');
                         }
                 }
         }
@@ -523,7 +527,7 @@ static int sn_topology_show(struct seq_file *s, void *d)
                         if (obj->sn_hwp_this_part && p->sn_hwp_this_part)
                                 /* both ends local to this partition */
                                 seq_puts(s, " local");
-                        else if (!obj->sn_hwp_this_part && !p->sn_hwp_this_part)
+                        else if (SN_HWPERF_FOREIGN(p))
                                 /* both ends of the link in foreign partiton */
                                 seq_puts(s, " foreign");
                         else
@@ -776,7 +780,7 @@ sn_hwperf_ioctl(struct inode *in, struct file *fp, u32 op, u64 arg)
 
         case SN_HWPERF_GET_NODE_NASID:
                 if (a.sz != sizeof(u64) ||
-                   (node = a.arg) < 0 || !node_possible(node)) {
+                   (node = a.arg) < 0 || !cnode_possible(node)) {
                         r = -EINVAL;
                         goto error;
                 }
diff --git a/arch/ia64/sn/pci/tioce_provider.c b/arch/ia64/sn/pci/tioce_provider.c
index 4cac7bdc7c7f..2d7948567ebc 100644
--- a/arch/ia64/sn/pci/tioce_provider.c
+++ b/arch/ia64/sn/pci/tioce_provider.c
@@ -3,7 +3,7 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (C) 2003-2005 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (C) 2003-2006 Silicon Graphics, Inc.  All Rights Reserved.
  */
 
 #include <linux/types.h>
@@ -1023,7 +1023,7 @@ tioce_bus_fixup(struct pcibus_bussoft *prom_bussoft, struct pci_controller *cont
         tioce_mmr_seti(tioce_kern, &tioce_mmr->ce_adm_int_status_alias, ~0ULL);
         tioce_mmr_seti(tioce_kern, &tioce_mmr->ce_adm_error_summary_alias,
                        ~0ULL);
-        tioce_mmr_seti(tioce_kern, &tioce_mmr->ce_dre_comp_err_addr, ~0ULL);
+        tioce_mmr_seti(tioce_kern, &tioce_mmr->ce_dre_comp_err_addr, 0ULL);
 
         if (request_irq(SGI_PCIASIC_ERROR,
                         tioce_error_intr_handler,