87 files changed, 3831 insertions, 2215 deletions

diff --git a/arch/ppc64/Kconfig b/arch/ppc64/Kconfig
index 5cb343883e4d..f804f25232ac 100644
--- a/arch/ppc64/Kconfig
+++ b/arch/ppc64/Kconfig
@@ -77,6 +77,10 @@ config PPC_PSERIES
         bool "  IBM pSeries & new iSeries"
         default y
 
+config PPC_BPA
+        bool "  Broadband Processor Architecture"
+        depends on PPC_MULTIPLATFORM
+
 config PPC_PMAC
         depends on PPC_MULTIPLATFORM
         bool "  Apple G5 based machines"
@@ -106,6 +110,21 @@ config PPC_OF
         bool
         default y
 
+config XICS
+        depends on PPC_PSERIES
+        bool
+        default y
+
+config MPIC
+        depends on PPC_PSERIES || PPC_PMAC || PPC_MAPLE
+        bool
+        default y
+
+config BPA_IIC
+        depends on PPC_BPA
+        bool
+        default y
+
 # VMX is pSeries only for now until somebody writes the iSeries
 # exception vectors for it
 config ALTIVEC
@@ -123,6 +142,23 @@ config PPC_SPLPAR
           processors, that is, which share physical processors between
           two or more partitions.
 
+config KEXEC
+        bool "kexec system call (EXPERIMENTAL)"
+        depends on PPC_MULTIPLATFORM && EXPERIMENTAL
+        help
+          kexec is a system call that implements the ability to shutdown your
+          current kernel, and to start another kernel.  It is like a reboot
+          but it is indepedent of the system firmware.  And like a reboot
+          you can start any kernel with it, not just Linux.
+
+          The name comes from the similiarity to the exec system call.
+
+          It is an ongoing process to be certain the hardware in a machine
+          is properly shutdown, so do not be surprised if this code does not
+          initially work for you.  It may help to enable device hotplugging
+          support.  As of this writing the exact hardware interface is
+          strongly in flux, so no good recommendation can be made.
+
 config IBMVIO
         depends on PPC_PSERIES || PPC_ISERIES
         bool
@@ -198,13 +234,49 @@ config HMT
           This option enables hardware multithreading on RS64 cpus.
           pSeries systems p620 and p660 have such a cpu type.
 
-config DISCONTIGMEM
-        bool "Discontiguous Memory Support"
+config ARCH_SELECT_MEMORY_MODEL
+        def_bool y
+
+config ARCH_FLATMEM_ENABLE
+       def_bool y
+       depends on !NUMA
+
+config ARCH_DISCONTIGMEM_ENABLE
+        def_bool y
         depends on SMP && PPC_PSERIES
 
+config ARCH_DISCONTIGMEM_DEFAULT
+        def_bool y
+        depends on ARCH_DISCONTIGMEM_ENABLE
+
+config ARCH_FLATMEM_ENABLE
+        def_bool y
+
+config ARCH_SPARSEMEM_ENABLE
+        def_bool y
+        depends on ARCH_DISCONTIGMEM_ENABLE
+
+source "mm/Kconfig"
+
+config HAVE_ARCH_EARLY_PFN_TO_NID
+        def_bool y
+        depends on NEED_MULTIPLE_NODES
+
+# Some NUMA nodes have memory ranges that span
+# other nodes.  Even though a pfn is valid and
+# between a node's start and end pfns, it may not
+# reside on that node.
+#
+# This is a relatively temporary hack that should
+# be able to go away when sparsemem is fully in
+# place
+config NODES_SPAN_OTHER_NODES
+        def_bool y
+        depends on NEED_MULTIPLE_NODES
+
 config NUMA
         bool "NUMA support"
-        depends on DISCONTIGMEM
+        default y if DISCONTIGMEM || SPARSEMEM
 
 config SCHED_SMT
         bool "SMT (Hyperthreading) scheduler support"
@@ -215,26 +287,7 @@ config SCHED_SMT
           when dealing with POWER5 cpus at a cost of slightly increased
           overhead in some places. If unsure say N here.
 
-config PREEMPT
-        bool "Preemptible Kernel"
-        help
-          This option reduces the latency of the kernel when reacting to
-          real-time or interactive events by allowing a low priority process to
-          be preempted even if it is in kernel mode executing a system call.
-
-          Say Y here if you are building a kernel for a desktop, embedded
-          or real-time system.  Say N if you are unsure.
-
-config PREEMPT_BKL
-        bool "Preempt The Big Kernel Lock"
-        depends on PREEMPT
-        default y
-        help
-          This option reduces the latency of the kernel by making the
-          big kernel lock preemptible.
-
-          Say Y here if you are building a kernel for a desktop system.
-          Say N if you are unsure.
+source "kernel/Kconfig.preempt"
 
 config EEH
         bool "PCI Extended Error Handling (EEH)" if EMBEDDED
@@ -256,7 +309,7 @@ config MSCHUNKS
 
 config PPC_RTAS
         bool
-        depends on PPC_PSERIES
+        depends on PPC_PSERIES || PPC_BPA
         default y
 
 config RTAS_PROC
@@ -323,7 +376,7 @@ config EISA
         bool
 
 config PCI
-        bool
+        bool "support for PCI devices" if (EMBEDDED && PPC_ISERIES)
         default y
         help
           Find out whether your system includes a PCI bus. PCI is the name of
diff --git a/arch/ppc64/Makefile b/arch/ppc64/Makefile
index 691f3008e698..731b84758331 100644
--- a/arch/ppc64/Makefile
+++ b/arch/ppc64/Makefile
@@ -35,9 +35,9 @@ CROSS32AS	:= $(AS) -a32
 CROSS32LD       := $(LD) -m elf32ppc
 CROSS32OBJCOPY  := $(OBJCOPY)
 endif
-AS              := $(AS) -a64
-LD              := $(LD) -m elf64ppc
-CC              := $(CC) -m64
+override AS     += -a64
+override LD     += -m elf64ppc
+override CC     += -m64
 endif
 
 export CROSS32CC CROSS32AS CROSS32LD CROSS32OBJCOPY
@@ -90,12 +90,14 @@ boot := arch/ppc64/boot
 boottarget-$(CONFIG_PPC_PSERIES) := zImage zImage.initrd
 boottarget-$(CONFIG_PPC_MAPLE) := zImage zImage.initrd
 boottarget-$(CONFIG_PPC_ISERIES) := vmlinux.sminitrd vmlinux.initrd vmlinux.sm
+boottarget-$(CONFIG_PPC_BPA) := zImage zImage.initrd
 $(boottarget-y): vmlinux
         $(Q)$(MAKE) $(build)=$(boot) $(boot)/$@
 
 bootimage-$(CONFIG_PPC_PSERIES) := $(boot)/zImage
 bootimage-$(CONFIG_PPC_PMAC) := vmlinux
 bootimage-$(CONFIG_PPC_MAPLE) := $(boot)/zImage
+bootimage-$(CONFIG_PPC_BPA) := zImage
 bootimage-$(CONFIG_PPC_ISERIES) := vmlinux
 BOOTIMAGE := $(bootimage-y)
 install: vmlinux
diff --git a/arch/ppc64/boot/Makefile b/arch/ppc64/boot/Makefile
index d3e1d6af9203..683b2d43c15f 100644
--- a/arch/ppc64/boot/Makefile
+++ b/arch/ppc64/boot/Makefile
@@ -52,7 +52,7 @@ obj-sec = $(foreach section, $(1), $(patsubst %,$(obj)/kernel-%.o, $(section)))
 src-sec = $(foreach section, $(1), $(patsubst %,$(obj)/kernel-%.c, $(section)))
 gz-sec  = $(foreach section, $(1), $(patsubst %,$(obj)/kernel-%.gz, $(section)))
 
-hostprogs-y             := piggy addnote addRamDisk
+hostprogs-y             := addnote addRamDisk
 targets                 += zImage zImage.initrd imagesize.c \
                            $(patsubst $(obj)/%,%, $(call obj-sec, $(required) $(initrd))) \
                            $(patsubst $(obj)/%,%, $(call src-sec, $(required) $(initrd))) \
@@ -78,9 +78,6 @@ addsection = $(CROSS32OBJCOPY) $(1) \
 quiet_cmd_addnote = ADDNOTE $@ 
       cmd_addnote = $(CROSS32LD) $(BOOTLFLAGS) -o $@ $(obj-boot) && $(obj)/addnote $@
 
-quiet_cmd_piggy = PIGGY   $@
-      cmd_piggy = $(obj)/piggyback $(@:.o=) < $< | $(CROSS32AS) -o $@
-
 $(call gz-sec, $(required)): $(obj)/kernel-%.gz: % FORCE
         $(call if_changed,gzip)
 
diff --git a/arch/ppc64/boot/install.sh b/arch/ppc64/boot/install.sh
index 955c5681db6c..cb2d6626b555 100644
--- a/arch/ppc64/boot/install.sh
+++ b/arch/ppc64/boot/install.sh
@@ -22,8 +22,8 @@
 
 # User may have a custom install script
 
-if [ -x ~/bin/installkernel ]; then exec ~/bin/installkernel "$@"; fi
-if [ -x /sbin/installkernel ]; then exec /sbin/installkernel "$@"; fi
+if [ -x ~/bin/${CROSS_COMPILE}installkernel ]; then exec ~/bin/${CROSS_COMPILE}installkernel "$@"; fi
+if [ -x /sbin/${CROSS_COMPILE}installkernel ]; then exec /sbin/${CROSS_COMPILE}installkernel "$@"; fi
 
 # Default install
 
diff --git a/arch/ppc64/boot/main.c b/arch/ppc64/boot/main.c
index da12ea2ca464..199d9804f61c 100644
--- a/arch/ppc64/boot/main.c
+++ b/arch/ppc64/boot/main.c
@@ -17,7 +17,6 @@
 
 extern void *finddevice(const char *);
 extern int getprop(void *, const char *, void *, int);
-extern void printk(char *fmt, ...);
 extern void printf(const char *fmt, ...);
 extern int sprintf(char *buf, const char *fmt, ...);
 void gunzip(void *, int, unsigned char *, int *);
@@ -147,10 +146,10 @@ void start(unsigned long a1, unsigned long a2, void *promptr)
                 }
                 a1 = initrd.addr;
                 a2 = initrd.size;
-                printf("initial ramdisk moving 0x%lx <- 0x%lx (%lx bytes)\n\r",
+                printf("initial ramdisk moving 0x%lx <- 0x%lx (0x%lx bytes)\n\r",
                        initrd.addr, (unsigned long)_initrd_start, initrd.size);
                 memmove((void *)initrd.addr, (void *)_initrd_start, initrd.size);
-                printf("initrd head: 0x%lx\n\r", *((u32 *)initrd.addr));
+                printf("initrd head: 0x%lx\n\r", *((unsigned long *)initrd.addr));
         }
 
         /* Eventually gunzip the kernel */
@@ -201,9 +200,6 @@ void start(unsigned long a1, unsigned long a2, void *promptr)
 
         flush_cache((void *)vmlinux.addr, vmlinux.size);
 
-        if (a1)
-                printf("initrd head: 0x%lx\n\r", *((u32 *)initrd.addr));
-
         kernel_entry = (kernel_entry_t)vmlinux.addr;
 #ifdef DEBUG
         printf( "kernel:\n\r"
diff --git a/arch/ppc64/boot/mknote.c b/arch/ppc64/boot/mknote.c
deleted file mode 100644
index 120cc1d89739..000000000000
--- a/arch/ppc64/boot/mknote.c
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (C) Cort Dougan 1999.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
- *
- * Generate a note section as per the CHRP specification.
- *
- */
-
-#include <stdio.h>
-
-#define PL(x) printf("%c%c%c%c", ((x)>>24)&0xff, ((x)>>16)&0xff, ((x)>>8)&0xff, (x)&0xff );
-
-int main(void)
-{
-/* header */
-        /* namesz */
-        PL(strlen("PowerPC")+1);
-        /* descrsz */
-        PL(6*4);
-        /* type */
-        PL(0x1275);
-        /* name */
-        printf("PowerPC"); printf("%c", 0);
-        
-/* descriptor */
-        /* real-mode */
-        PL(0xffffffff);
-        /* real-base */
-        PL(0x00c00000);
-        /* real-size */
-        PL(0xffffffff);
-        /* virt-base */
-        PL(0xffffffff);
-        /* virt-size */
-        PL(0xffffffff);
-        /* load-base */
-        PL(0x4000);
-        return 0;
-}
diff --git a/arch/ppc64/boot/piggyback.c b/arch/ppc64/boot/piggyback.c
deleted file mode 100644
index 235c7a87269c..000000000000
--- a/arch/ppc64/boot/piggyback.c
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright 2001 IBM Corp 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
- */
-#include <stdio.h>
-#include <unistd.h>
-#include <string.h>
-
-extern long ce_exec_config[];
-
-int main(int argc, char *argv[])
-{
-        int i, cnt, pos, len;
-        unsigned int cksum, val;
-        unsigned char *lp;
-        unsigned char buf[8192];
-        char *varname;
-        if (argc != 2)
-        {
-                fprintf(stderr, "usage: %s name <in-file >out-file\n",
-                        argv[0]);
-                exit(1);
-        }
-
-        varname = strrchr(argv[1], '/');
-        if (varname)
-                varname++;
-        else
-                varname = argv[1];
-
-        fprintf(stdout, "#\n");
-        fprintf(stdout, "# Miscellaneous data structures:\n");
-        fprintf(stdout, "# WARNING - this file is automatically generated!\n");
-        fprintf(stdout, "#\n");
-        fprintf(stdout, "\n");
-        fprintf(stdout, "\t.data\n");
-        fprintf(stdout, "\t.globl %s_data\n", varname);
-        fprintf(stdout, "%s_data:\n", varname);
-        pos = 0;
-        cksum = 0;
-        while ((len = read(0, buf, sizeof(buf))) > 0)
-        {
-                cnt = 0;
-                lp = (unsigned char *)buf;
-                len = (len + 3) & ~3;  /* Round up to longwords */
-                for (i = 0;  i < len;  i += 4)
-                {
-                        if (cnt == 0)
-                        {
-                                fprintf(stdout, "\t.long\t");
-                        }
-                        fprintf(stdout, "0x%02X%02X%02X%02X", lp[0], lp[1], lp[2], lp[3]);
-                        val = *(unsigned long *)lp;
-                        cksum ^= val;
-                        lp += 4;
-                        if (++cnt == 4)
-                        {
-                                cnt = 0;
-                                fprintf(stdout, " # %x \n", pos+i-12);
-                                fflush(stdout);
-                        } else
-                        {
-                                fprintf(stdout, ",");
-                        }
-                }
-                if (cnt)
-                {
-                        fprintf(stdout, "0\n");
-                }
-                pos += len;
-        }
-        fprintf(stdout, "\t.globl %s_len\n", varname);
-        fprintf(stdout, "%s_len:\t.long\t0x%x\n", varname, pos);
-        fflush(stdout);
-        fclose(stdout);
-        fprintf(stderr, "cksum = %x\n", cksum);
-        exit(0);
-}
-
diff --git a/arch/ppc64/boot/prom.c b/arch/ppc64/boot/prom.c
index d5218b15824e..5e48b80ff5a0 100644
--- a/arch/ppc64/boot/prom.c
+++ b/arch/ppc64/boot/prom.c
@@ -40,7 +40,7 @@ void *finddevice(const char *name);
 int getprop(void *phandle, const char *name, void *buf, int buflen);
 void chrpboot(int a1, int a2, void *prom);      /* in main.c */
 
-void printk(char *fmt, ...);
+int printf(char *fmt, ...);
 
 /* there is no convenient header to get this from...  -- paulus */
 extern unsigned long strlen(const char *);
@@ -220,7 +220,7 @@ readchar(void)
                 case 1:
                         return ch;
                 case -1:
-                        printk("read(stdin) returned -1\r\n");
+                        printf("read(stdin) returned -1\r\n");
                         return -1;
                 }
         }
@@ -627,18 +627,6 @@ int sprintf(char * buf, const char *fmt, ...)
 
 static char sprint_buf[1024];
 
-void
-printk(char *fmt, ...)
-{
-        va_list args;
-        int n;
-
-        va_start(args, fmt);
-        n = vsprintf(sprint_buf, fmt, args);
-        va_end(args);
-        write(stdout, sprint_buf, n);
-}
-
 int
 printf(char *fmt, ...)
 {
diff --git a/arch/ppc64/configs/pSeries_defconfig b/arch/ppc64/configs/pSeries_defconfig
index 3eb5ef25d3a3..d0db8b5966c0 100644
--- a/arch/ppc64/configs/pSeries_defconfig
+++ b/arch/ppc64/configs/pSeries_defconfig
@@ -88,7 +88,7 @@ CONFIG_IBMVIO=y
 CONFIG_IOMMU_VMERGE=y
 CONFIG_SMP=y
 CONFIG_NR_CPUS=128
-CONFIG_DISCONTIGMEM=y
+CONFIG_ARCH_DISCONTIGMEM_ENABLE=y
 CONFIG_NUMA=y
 CONFIG_SCHED_SMT=y
 # CONFIG_PREEMPT is not set
diff --git a/arch/ppc64/defconfig b/arch/ppc64/defconfig
index 2f31bf3046f9..b8e2066dde77 100644
--- a/arch/ppc64/defconfig
+++ b/arch/ppc64/defconfig
@@ -89,7 +89,7 @@ CONFIG_BOOTX_TEXT=y
 CONFIG_IOMMU_VMERGE=y
 CONFIG_SMP=y
 CONFIG_NR_CPUS=32
-CONFIG_DISCONTIGMEM=y
+CONFIG_ARCH_DISCONTIGMEM_ENABLE=y
 # CONFIG_NUMA is not set
 # CONFIG_SCHED_SMT is not set
 # CONFIG_PREEMPT is not set
diff --git a/arch/ppc64/kernel/HvLpEvent.c b/arch/ppc64/kernel/HvLpEvent.c
index f8f19637f73f..90032b138902 100644
--- a/arch/ppc64/kernel/HvLpEvent.c
+++ b/arch/ppc64/kernel/HvLpEvent.c
@@ -12,7 +12,7 @@
 #include <asm/system.h>
 #include <asm/iSeries/HvLpEvent.h>
 #include <asm/iSeries/HvCallEvent.h>
-#include <asm/iSeries/LparData.h>
+#include <asm/iSeries/ItLpNaca.h>
 
 /* Array of LpEvent handler functions */
 LpEventHandler lpEventHandler[HvLpEvent_Type_NumTypes];
diff --git a/arch/ppc64/kernel/ItLpQueue.c b/arch/ppc64/kernel/ItLpQueue.c
index c923a815760e..4231861288a3 100644
--- a/arch/ppc64/kernel/ItLpQueue.c
+++ b/arch/ppc64/kernel/ItLpQueue.c
@@ -1,7 +1,7 @@
 /*
  * ItLpQueue.c
  * Copyright (C) 2001 Mike Corrigan  IBM Corporation
- * 
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
@@ -11,157 +11,252 @@
 #include <linux/stddef.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
+#include <linux/bootmem.h>
+#include <linux/seq_file.h>
+#include <linux/proc_fs.h>
 #include <asm/system.h>
 #include <asm/paca.h>
 #include <asm/iSeries/ItLpQueue.h>
 #include <asm/iSeries/HvLpEvent.h>
 #include <asm/iSeries/HvCallEvent.h>
-#include <asm/iSeries/LparData.h>
 
-static __inline__ int set_inUse( struct ItLpQueue * lpQueue )
-{
-        int t;
-        u32 * inUseP = &(lpQueue->xInUseWord);
-
-        __asm__ __volatile__("\n\
-1:      lwarx   %0,0,%2         \n\
-        cmpwi   0,%0,0          \n\
-        li      %0,0            \n\
-        bne-    2f              \n\
-        addi    %0,%0,1         \n\
-        stwcx.  %0,0,%2         \n\
-        bne-    1b              \n\
-2:      eieio"
-        : "=&r" (t), "=m" (lpQueue->xInUseWord)
-        : "r" (inUseP), "m" (lpQueue->xInUseWord)
-        : "cc");
-
-        return t;
-}
+/*
+ * The LpQueue is used to pass event data from the hypervisor to
+ * the partition.  This is where I/O interrupt events are communicated.
+ *
+ * It is written to by the hypervisor so cannot end up in the BSS.
+ */
+struct hvlpevent_queue hvlpevent_queue __attribute__((__section__(".data")));
 
-static __inline__ void clear_inUse( struct ItLpQueue * lpQueue )
-{
-        lpQueue->xInUseWord = 0;
-}
+DEFINE_PER_CPU(unsigned long[HvLpEvent_Type_NumTypes], hvlpevent_counts);
+
+static char *event_types[HvLpEvent_Type_NumTypes] = {
+        "Hypervisor",
+        "Machine Facilities",
+        "Session Manager",
+        "SPD I/O",
+        "Virtual Bus",
+        "PCI I/O",
+        "RIO I/O",
+        "Virtual Lan",
+        "Virtual I/O"
+};
 
 /* Array of LpEvent handler functions */
 extern LpEventHandler lpEventHandler[HvLpEvent_Type_NumTypes];
-unsigned long ItLpQueueInProcess = 0;
 
-struct HvLpEvent * ItLpQueue_getNextLpEvent( struct ItLpQueue * lpQueue )
+static struct HvLpEvent * get_next_hvlpevent(void)
 {
-        struct HvLpEvent * nextLpEvent = 
-                (struct HvLpEvent *)lpQueue->xSlicCurEventPtr;
-        if ( nextLpEvent->xFlags.xValid ) {
+        struct HvLpEvent * event;
+        event = (struct HvLpEvent *)hvlpevent_queue.xSlicCurEventPtr;
+
+        if (event->xFlags.xValid) {
                 /* rmb() needed only for weakly consistent machines (regatta) */
                 rmb();
                 /* Set pointer to next potential event */
-                lpQueue->xSlicCurEventPtr += ((nextLpEvent->xSizeMinus1 +
-                                      LpEventAlign ) /
-                                      LpEventAlign ) *
-                                      LpEventAlign;
+                hvlpevent_queue.xSlicCurEventPtr += ((event->xSizeMinus1 +
+                                LpEventAlign) / LpEventAlign) * LpEventAlign;
+
                 /* Wrap to beginning if no room at end */
-                if (lpQueue->xSlicCurEventPtr > lpQueue->xSlicLastValidEventPtr)
-                        lpQueue->xSlicCurEventPtr = lpQueue->xSlicEventStackPtr;
+                if (hvlpevent_queue.xSlicCurEventPtr >
+                                hvlpevent_queue.xSlicLastValidEventPtr) {
+                        hvlpevent_queue.xSlicCurEventPtr =
+                                hvlpevent_queue.xSlicEventStackPtr;
+                }
+        } else {
+                event = NULL;
         }
-        else 
-                nextLpEvent = NULL;
 
-        return nextLpEvent;
+        return event;
 }
 
-int ItLpQueue_isLpIntPending( struct ItLpQueue * lpQueue )
+static unsigned long spread_lpevents = NR_CPUS;
+
+int hvlpevent_is_pending(void)
 {
-        int retval = 0;
-        struct HvLpEvent * nextLpEvent;
-        if ( lpQueue ) {
-                nextLpEvent = (struct HvLpEvent *)lpQueue->xSlicCurEventPtr;
-                retval = nextLpEvent->xFlags.xValid | lpQueue->xPlicOverflowIntPending;
-        }
-        return retval;
+        struct HvLpEvent *next_event;
+
+        if (smp_processor_id() >= spread_lpevents)
+                return 0;
+
+        next_event = (struct HvLpEvent *)hvlpevent_queue.xSlicCurEventPtr;
+
+        return next_event->xFlags.xValid |
+                hvlpevent_queue.xPlicOverflowIntPending;
 }
 
-void ItLpQueue_clearValid( struct HvLpEvent * event )
+static void hvlpevent_clear_valid(struct HvLpEvent * event)
 {
-        /* Clear the valid bit of the event
-         * Also clear bits within this event that might
-         * look like valid bits (on 64-byte boundaries)
-         */
-        unsigned extra = (( event->xSizeMinus1 + LpEventAlign ) /
-                                                 LpEventAlign ) - 1;
-        switch ( extra ) {
-          case 3:
-           ((struct HvLpEvent*)((char*)event+3*LpEventAlign))->xFlags.xValid=0;
-          case 2:
-           ((struct HvLpEvent*)((char*)event+2*LpEventAlign))->xFlags.xValid=0;
-          case 1:
-           ((struct HvLpEvent*)((char*)event+1*LpEventAlign))->xFlags.xValid=0;
-          case 0:
-           ;    
+        /* Tell the Hypervisor that we're done with this event.
+         * Also clear bits within this event that might look like valid bits.
+         * ie. on 64-byte boundaries.
+         */
+        struct HvLpEvent *tmp;
+        unsigned extra = ((event->xSizeMinus1 + LpEventAlign) /
+                                                 LpEventAlign) - 1;
+
+        switch (extra) {
+        case 3:
+                tmp = (struct HvLpEvent*)((char*)event + 3 * LpEventAlign);
+                tmp->xFlags.xValid = 0;
+        case 2:
+                tmp = (struct HvLpEvent*)((char*)event + 2 * LpEventAlign);
+                tmp->xFlags.xValid = 0;
+        case 1:
+                tmp = (struct HvLpEvent*)((char*)event + 1 * LpEventAlign);
+                tmp->xFlags.xValid = 0;
         }
+
         mb();
+
         event->xFlags.xValid = 0;
 }
 
-unsigned ItLpQueue_process( struct ItLpQueue * lpQueue, struct pt_regs *regs )
+void process_hvlpevents(struct pt_regs *regs)
 {
-        unsigned numIntsProcessed = 0;
-        struct HvLpEvent * nextLpEvent;
+        struct HvLpEvent * event;
 
         /* If we have recursed, just return */
-        if ( !set_inUse( lpQueue ) )
-                return 0;
-        
-        if (ItLpQueueInProcess == 0)
-                ItLpQueueInProcess = 1;
-        else
-                BUG();
+        if (!spin_trylock(&hvlpevent_queue.lock))
+                return;
 
         for (;;) {
-                nextLpEvent = ItLpQueue_getNextLpEvent( lpQueue );
-                if ( nextLpEvent ) {
-                        /* Count events to return to caller
-                         * and count processed events in lpQueue
-                         */
-                        ++numIntsProcessed;
-                        lpQueue->xLpIntCount++;         
-                        /* Call appropriate handler here, passing 
+                event = get_next_hvlpevent();
+                if (event) {
+                        /* Call appropriate handler here, passing
                          * a pointer to the LpEvent.  The handler
                          * must make a copy of the LpEvent if it
                          * needs it in a bottom half. (perhaps for
                          * an ACK)
-                         *      
-                         *  Handlers are responsible for ACK processing 
+                         *
+                         *  Handlers are responsible for ACK processing
                          *
                          * The Hypervisor guarantees that LpEvents will
                          * only be delivered with types that we have
                          * registered for, so no type check is necessary
                          * here!
-                         */
-                        if ( nextLpEvent->xType < HvLpEvent_Type_NumTypes )
-                                lpQueue->xLpIntCountByType[nextLpEvent->xType]++;
-                        if ( nextLpEvent->xType < HvLpEvent_Type_NumTypes &&
-                             lpEventHandler[nextLpEvent->xType] ) 
-                                lpEventHandler[nextLpEvent->xType](nextLpEvent, regs);
+                         */
+                        if (event->xType < HvLpEvent_Type_NumTypes)
+                                __get_cpu_var(hvlpevent_counts)[event->xType]++;
+                        if (event->xType < HvLpEvent_Type_NumTypes &&
+                                        lpEventHandler[event->xType])
+                                lpEventHandler[event->xType](event, regs);
                         else
-                                printk(KERN_INFO "Unexpected Lp Event type=%d\n", nextLpEvent->xType );
-                        
-                        ItLpQueue_clearValid( nextLpEvent );
-                } else if ( lpQueue->xPlicOverflowIntPending )
+                                printk(KERN_INFO "Unexpected Lp Event type=%d\n", event->xType );
+
+                        hvlpevent_clear_valid(event);
+                } else if (hvlpevent_queue.xPlicOverflowIntPending)
                         /*
                          * No more valid events. If overflow events are
                          * pending process them
                          */
-                        HvCallEvent_getOverflowLpEvents( lpQueue->xIndex);
+                        HvCallEvent_getOverflowLpEvents(hvlpevent_queue.xIndex);
                 else
                         break;
         }
 
-        ItLpQueueInProcess = 0;
-        mb();
-        clear_inUse( lpQueue );
+        spin_unlock(&hvlpevent_queue.lock);
+}
+
+static int set_spread_lpevents(char *str)
+{
+        unsigned long val = simple_strtoul(str, NULL, 0);
+
+        /*
+         * The parameter is the number of processors to share in processing
+         * lp events.
+         */
+        if (( val > 0) && (val <= NR_CPUS)) {
+                spread_lpevents = val;
+                printk("lpevent processing spread over %ld processors\n", val);
+        } else {
+                printk("invalid spread_lpevents %ld\n", val);
+        }
 
-        get_paca()->lpevent_count += numIntsProcessed;
+        return 1;
+}
+__setup("spread_lpevents=", set_spread_lpevents);
+
+void setup_hvlpevent_queue(void)
+{
+        void *eventStack;
+
+        /*
+         * Allocate a page for the Event Stack. The Hypervisor needs the
+         * absolute real address, so we subtract out the KERNELBASE and add
+         * in the absolute real address of the kernel load area.
+         */
+        eventStack = alloc_bootmem_pages(LpEventStackSize);
+        memset(eventStack, 0, LpEventStackSize);
+
+        /* Invoke the hypervisor to initialize the event stack */
+        HvCallEvent_setLpEventStack(0, eventStack, LpEventStackSize);
+
+        hvlpevent_queue.xSlicEventStackPtr = (char *)eventStack;
+        hvlpevent_queue.xSlicCurEventPtr = (char *)eventStack;
+        hvlpevent_queue.xSlicLastValidEventPtr = (char *)eventStack +
+                                        (LpEventStackSize - LpEventMaxSize);
+        hvlpevent_queue.xIndex = 0;
+}
+
+static int proc_lpevents_show(struct seq_file *m, void *v)
+{
+        int cpu, i;
+        unsigned long sum;
+        static unsigned long cpu_totals[NR_CPUS];
+
+        /* FIXME: do we care that there's no locking here? */
+        sum = 0;
+        for_each_online_cpu(cpu) {
+                cpu_totals[cpu] = 0;
+                for (i = 0; i < HvLpEvent_Type_NumTypes; i++) {
+                        cpu_totals[cpu] += per_cpu(hvlpevent_counts, cpu)[i];
+                }
+                sum += cpu_totals[cpu];
+        }
+
+        seq_printf(m, "LpEventQueue 0\n");
+        seq_printf(m, "  events processed:\t%lu\n", sum);
+
+        for (i = 0; i < HvLpEvent_Type_NumTypes; ++i) {
+                sum = 0;
+                for_each_online_cpu(cpu) {
+                        sum += per_cpu(hvlpevent_counts, cpu)[i];
+                }
+
+                seq_printf(m, "    %-20s %10lu\n", event_types[i], sum);
+        }
+
+        seq_printf(m, "\n  events processed by processor:\n");
+
+        for_each_online_cpu(cpu) {
+                seq_printf(m, "    CPU%02d  %10lu\n", cpu, cpu_totals[cpu]);
+        }
+
+        return 0;
+}
+
+static int proc_lpevents_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, proc_lpevents_show, NULL);
+}
 
-        return numIntsProcessed;
+static struct file_operations proc_lpevents_operations = {
+        .open           = proc_lpevents_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static int __init proc_lpevents_init(void)
+{
+        struct proc_dir_entry *e;
+
+        e = create_proc_entry("iSeries/lpevents", S_IFREG|S_IRUGO, NULL);
+        if (e)
+                e->proc_fops = &proc_lpevents_operations;
+
+        return 0;
 }
+__initcall(proc_lpevents_init);
+
diff --git a/arch/ppc64/kernel/LparData.c b/arch/ppc64/kernel/LparData.c
index badc5a443614..6ffcf67dd507 100644
--- a/arch/ppc64/kernel/LparData.c
+++ b/arch/ppc64/kernel/LparData.c
@@ -28,13 +28,6 @@
 #include <asm/iSeries/IoHriProcessorVpd.h>
 #include <asm/iSeries/ItSpCommArea.h>
 
-/* The LpQueue is used to pass event data from the hypervisor to
- * the partition.  This is where I/O interrupt events are communicated.
- */
-
-/* May be filled in by the hypervisor so cannot end up in the BSS */
-struct ItLpQueue xItLpQueue __attribute__((__section__(".data")));
-
 
 /* The HvReleaseData is the root of the information shared between 
  * the hypervisor and Linux.  
@@ -200,7 +193,7 @@ struct ItVpdAreas itVpdAreas = {
                 0,0,0,                  /* 13 - 15 */
                 sizeof(struct IoHriProcessorVpd),/* 16 length of Proc Vpd */
                 0,0,0,0,0,0,            /* 17 - 22  */
-                sizeof(struct ItLpQueue),/*     23 length of Lp Queue */
+                sizeof(struct hvlpevent_queue), /* 23 length of Lp Queue */
                 0,0                     /* 24 - 25 */
                 },
         .xSlicVpdAdrs = {                       /* VPD addresses */
@@ -218,7 +211,7 @@ struct ItVpdAreas itVpdAreas = {
                 0,0,0,                  /* 13 - 15 */
                 &xIoHriProcessorVpd,    /*      16 Proc Vpd */
                 0,0,0,0,0,0,            /* 17 - 22 */
-                &xItLpQueue,            /*      23 Lp Queue */
+                &hvlpevent_queue,       /*      23 Lp Queue */
                 0,0
         }
 };
diff --git a/arch/ppc64/kernel/Makefile b/arch/ppc64/kernel/Makefile
index 96d90b0c5119..d9b2660ef221 100644
--- a/arch/ppc64/kernel/Makefile
+++ b/arch/ppc64/kernel/Makefile
@@ -16,29 +16,33 @@ obj-y += vdso32/ vdso64/
 
 obj-$(CONFIG_PPC_OF) += of_device.o
 
-pci-obj-$(CONFIG_PPC_ISERIES)   += iSeries_pci.o iSeries_pci_reset.o
+pci-obj-$(CONFIG_PPC_ISERIES)   += iSeries_pci.o iSeries_irq.o \
+                                iSeries_VpdInfo.o
 pci-obj-$(CONFIG_PPC_MULTIPLATFORM)     += pci_dn.o pci_direct_iommu.o
 
 obj-$(CONFIG_PCI)       += pci.o pci_iommu.o iomap.o $(pci-obj-y)
 
-obj-$(CONFIG_PPC_ISERIES) += iSeries_irq.o \
-                             iSeries_VpdInfo.o XmPciLpEvent.o \
-                             HvCall.o HvLpConfig.o LparData.o \
+obj-$(CONFIG_PPC_ISERIES) += HvCall.o HvLpConfig.o LparData.o \
                              iSeries_setup.o ItLpQueue.o hvCall.o \
                              mf.o HvLpEvent.o iSeries_proc.o iSeries_htab.o \
                              iSeries_iommu.o
 
-obj-$(CONFIG_PPC_MULTIPLATFORM) += nvram.o i8259.o prom_init.o prom.o mpic.o
+obj-$(CONFIG_PPC_MULTIPLATFORM) += nvram.o i8259.o prom_init.o prom.o
 
 obj-$(CONFIG_PPC_PSERIES) += pSeries_pci.o pSeries_lpar.o pSeries_hvCall.o \
                              pSeries_nvram.o rtasd.o ras.o pSeries_reconfig.o \
-                             xics.o rtas.o pSeries_setup.o pSeries_iommu.o
+                             pSeries_setup.o pSeries_iommu.o
 
+obj-$(CONFIG_PPC_BPA) += bpa_setup.o bpa_iommu.o bpa_nvram.o \
+                         bpa_iic.o spider-pic.o
+
+obj-$(CONFIG_KEXEC)             += machine_kexec.o
 obj-$(CONFIG_EEH)               += eeh.o
 obj-$(CONFIG_PROC_FS)           += proc_ppc64.o
 obj-$(CONFIG_RTAS_FLASH)        += rtas_flash.o
 obj-$(CONFIG_SMP)               += smp.o
 obj-$(CONFIG_MODULES)           += module.o ppc_ksyms.o
+obj-$(CONFIG_PPC_RTAS)          += rtas.o rtas_pci.o
 obj-$(CONFIG_RTAS_PROC)         += rtas-proc.o
 obj-$(CONFIG_SCANLOG)           += scanlog.o
 obj-$(CONFIG_VIOPATH)           += viopath.o
@@ -47,6 +51,8 @@ obj-$(CONFIG_HVC_CONSOLE)	+= hvconsole.o
 obj-$(CONFIG_BOOTX_TEXT)        += btext.o
 obj-$(CONFIG_HVCS)              += hvcserver.o
 obj-$(CONFIG_IBMVIO)            += vio.o
+obj-$(CONFIG_XICS)              += xics.o
+obj-$(CONFIG_MPIC)              += mpic.o
 
 obj-$(CONFIG_PPC_PMAC)          += pmac_setup.o pmac_feature.o pmac_pci.o \
                                    pmac_time.o pmac_nvram.o pmac_low_i2c.o
@@ -59,6 +65,7 @@ ifdef CONFIG_SMP
 obj-$(CONFIG_PPC_PMAC)          += pmac_smp.o smp-tbsync.o
 obj-$(CONFIG_PPC_ISERIES)       += iSeries_smp.o
 obj-$(CONFIG_PPC_PSERIES)       += pSeries_smp.o
+obj-$(CONFIG_PPC_BPA)           += pSeries_smp.o
 obj-$(CONFIG_PPC_MAPLE)         += smp-tbsync.o
 endif
 
diff --git a/arch/ppc64/kernel/XmPciLpEvent.c b/arch/ppc64/kernel/XmPciLpEvent.c
deleted file mode 100644
index 809c9bc6678b..000000000000
--- a/arch/ppc64/kernel/XmPciLpEvent.c
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * File XmPciLpEvent.h created by Wayne Holm on Mon Jan 15 2001.
- *
- * This module handles PCI interrupt events sent by the iSeries Hypervisor.
-*/
-
-#include <linux/config.h>
-#include <linux/pci.h>
-#include <linux/init.h>
-#include <linux/threads.h>
-#include <linux/smp.h>
-#include <linux/param.h>
-#include <linux/string.h>
-#include <linux/bootmem.h>
-#include <linux/ide.h>
-
-#include <asm/iSeries/HvTypes.h>
-#include <asm/iSeries/HvLpEvent.h>
-#include <asm/iSeries/HvCallPci.h>
-#include <asm/iSeries/XmPciLpEvent.h>
-#include <asm/ppcdebug.h>
-
-static long Pci_Interrupt_Count;
-static long Pci_Event_Count;
-
-enum XmPciLpEvent_Subtype {
-        XmPciLpEvent_BusCreated    = 0,         // PHB has been created
-        XmPciLpEvent_BusError      = 1,         // PHB has failed
-        XmPciLpEvent_BusFailed     = 2,         // Msg to Secondary, Primary failed bus
-        XmPciLpEvent_NodeFailed    = 4,         // Multi-adapter bridge has failed
-        XmPciLpEvent_NodeRecovered = 5,         // Multi-adapter bridge has recovered
-        XmPciLpEvent_BusRecovered  = 12,        // PHB has been recovered
-        XmPciLpEvent_UnQuiesceBus  = 18,        // Secondary bus unqiescing
-        XmPciLpEvent_BridgeError   = 21,        // Bridge Error
-        XmPciLpEvent_SlotInterrupt = 22         // Slot interrupt
-};
-
-struct XmPciLpEvent_BusInterrupt {
-        HvBusNumber     busNumber;
-        HvSubBusNumber  subBusNumber;
-};
-
-struct XmPciLpEvent_NodeInterrupt {
-        HvBusNumber     busNumber;
-        HvSubBusNumber  subBusNumber;
-        HvAgentId       deviceId;
-};
-
-struct XmPciLpEvent {
-        struct HvLpEvent hvLpEvent;
-
-        union {
-                u64 alignData;                  // Align on an 8-byte boundary
-
-                struct {
-                        u32             fisr;
-                        HvBusNumber     busNumber;
-                        HvSubBusNumber  subBusNumber;
-                        HvAgentId       deviceId;
-                } slotInterrupt;
-
-                struct XmPciLpEvent_BusInterrupt busFailed;
-                struct XmPciLpEvent_BusInterrupt busRecovered;
-                struct XmPciLpEvent_BusInterrupt busCreated;
-
-                struct XmPciLpEvent_NodeInterrupt nodeFailed;
-                struct XmPciLpEvent_NodeInterrupt nodeRecovered;
-
-        } eventData;
-
-};
-
-static void intReceived(struct XmPciLpEvent *eventParm,
-                struct pt_regs *regsParm);
-
-static void XmPciLpEvent_handler(struct HvLpEvent *eventParm,
-                struct pt_regs *regsParm)
-{
-#ifdef CONFIG_PCI
-#if 0
-        PPCDBG(PPCDBG_BUSWALK, "XmPciLpEvent_handler, type 0x%x\n",
-                        eventParm->xType);
-#endif
-        ++Pci_Event_Count;
-
-        if (eventParm && (eventParm->xType == HvLpEvent_Type_PciIo)) {
-                switch (eventParm->xFlags.xFunction) {
-                case HvLpEvent_Function_Int:
-                        intReceived((struct XmPciLpEvent *)eventParm, regsParm);
-                        break;
-                case HvLpEvent_Function_Ack:
-                        printk(KERN_ERR
-                                "XmPciLpEvent.c: unexpected ack received\n");
-                        break;
-                default:
-                        printk(KERN_ERR
-                                "XmPciLpEvent.c: unexpected event function %d\n",
-                                (int)eventParm->xFlags.xFunction);
-                        break;
-                }
-        } else if (eventParm)
-                printk(KERN_ERR
-                        "XmPciLpEvent.c: Unrecognized PCI event type 0x%x\n",
-                        (int)eventParm->xType);
-        else
-                printk(KERN_ERR "XmPciLpEvent.c: NULL event received\n");
-#endif
-}
-
-static void intReceived(struct XmPciLpEvent *eventParm,
-                struct pt_regs *regsParm)
-{
-        int irq;
-
-        ++Pci_Interrupt_Count;
-#if 0
-        PPCDBG(PPCDBG_BUSWALK, "PCI: XmPciLpEvent.c: intReceived\n");
-#endif
-
-        switch (eventParm->hvLpEvent.xSubtype) {
-        case XmPciLpEvent_SlotInterrupt:
-                irq = eventParm->hvLpEvent.xCorrelationToken;
-                /* Dispatch the interrupt handlers for this irq */
-                ppc_irq_dispatch_handler(regsParm, irq);
-                HvCallPci_eoi(eventParm->eventData.slotInterrupt.busNumber,
-                        eventParm->eventData.slotInterrupt.subBusNumber,
-                        eventParm->eventData.slotInterrupt.deviceId);
-                break;
-                /* Ignore error recovery events for now */
-        case XmPciLpEvent_BusCreated:
-                printk(KERN_INFO "XmPciLpEvent.c: system bus %d created\n",
-                        eventParm->eventData.busCreated.busNumber);
-                break;
-        case XmPciLpEvent_BusError:
-        case XmPciLpEvent_BusFailed:
-                printk(KERN_INFO "XmPciLpEvent.c: system bus %d failed\n",
-                        eventParm->eventData.busFailed.busNumber);
-                break;
-        case XmPciLpEvent_BusRecovered:
-        case XmPciLpEvent_UnQuiesceBus:
-                printk(KERN_INFO "XmPciLpEvent.c: system bus %d recovered\n",
-                        eventParm->eventData.busRecovered.busNumber);
-                break;
-        case XmPciLpEvent_NodeFailed:
-        case XmPciLpEvent_BridgeError:
-                printk(KERN_INFO
-                        "XmPciLpEvent.c: multi-adapter bridge %d/%d/%d failed\n",
-                        eventParm->eventData.nodeFailed.busNumber,
-                        eventParm->eventData.nodeFailed.subBusNumber,
-                        eventParm->eventData.nodeFailed.deviceId);
-                break;
-        case XmPciLpEvent_NodeRecovered:
-                printk(KERN_INFO
-                        "XmPciLpEvent.c: multi-adapter bridge %d/%d/%d recovered\n",
-                        eventParm->eventData.nodeRecovered.busNumber,
-                        eventParm->eventData.nodeRecovered.subBusNumber,
-                        eventParm->eventData.nodeRecovered.deviceId);
-                break;
-        default:
-                printk(KERN_ERR
-                        "XmPciLpEvent.c: unrecognized event subtype 0x%x\n",
-                        eventParm->hvLpEvent.xSubtype);
-                break;
-        }
-}
-
-
-/* This should be called sometime prior to buswalk (init_IRQ would be good) */
-int XmPciLpEvent_init()
-{
-        int xRc;
-
-        PPCDBG(PPCDBG_BUSWALK,
-                        "XmPciLpEvent_init, Register Event type 0x%04X\n",
-                        HvLpEvent_Type_PciIo);
-
-        xRc = HvLpEvent_registerHandler(HvLpEvent_Type_PciIo,
-                        &XmPciLpEvent_handler);
-        if (xRc == 0) {
-                xRc = HvLpEvent_openPath(HvLpEvent_Type_PciIo, 0);
-                if (xRc != 0)
-                        printk(KERN_ERR
-                                "XmPciLpEvent.c: open event path failed with rc 0x%x\n",
-                                xRc);
-        } else
-                printk(KERN_ERR
-                        "XmPciLpEvent.c: register handler failed with rc 0x%x\n",
-                        xRc);
-        return xRc;
-}
diff --git a/arch/ppc64/kernel/asm-offsets.c b/arch/ppc64/kernel/asm-offsets.c
index 0094ac79a18c..abb9e5b5da03 100644
--- a/arch/ppc64/kernel/asm-offsets.c
+++ b/arch/ppc64/kernel/asm-offsets.c
@@ -31,7 +31,6 @@
 
 #include <asm/paca.h>
 #include <asm/lppaca.h>
-#include <asm/iSeries/ItLpQueue.h>
 #include <asm/iSeries/HvLpEvent.h>
 #include <asm/rtas.h>
 #include <asm/cputable.h>
diff --git a/arch/ppc64/kernel/bpa_iic.c b/arch/ppc64/kernel/bpa_iic.c
new file mode 100644
index 000000000000..c8f3dc3fad70
--- /dev/null
+++ b/arch/ppc64/kernel/bpa_iic.c
@@ -0,0 +1,270 @@
+/*
+ * BPA Internal Interrupt Controller
+ *
+ * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
+ *
+ * Author: Arnd Bergmann <arndb@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/config.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/percpu.h>
+#include <linux/types.h>
+
+#include <asm/io.h>
+#include <asm/pgtable.h>
+#include <asm/prom.h>
+#include <asm/ptrace.h>
+
+#include "bpa_iic.h"
+
+struct iic_pending_bits {
+        u32 data;
+        u8 flags;
+        u8 class;
+        u8 source;
+        u8 prio;
+};
+
+enum iic_pending_flags {
+        IIC_VALID = 0x80,
+        IIC_IPI   = 0x40,
+};
+
+struct iic_regs {
+        struct iic_pending_bits pending;
+        struct iic_pending_bits pending_destr;
+        u64 generate;
+        u64 prio;
+};
+
+struct iic {
+        struct iic_regs __iomem *regs;
+};
+
+static DEFINE_PER_CPU(struct iic, iic);
+
+void iic_local_enable(void)
+{
+        out_be64(&__get_cpu_var(iic).regs->prio, 0xff);
+}
+
+void iic_local_disable(void)
+{
+        out_be64(&__get_cpu_var(iic).regs->prio, 0x0);
+}
+
+static unsigned int iic_startup(unsigned int irq)
+{
+        return 0;
+}
+
+static void iic_enable(unsigned int irq)
+{
+        iic_local_enable();
+}
+
+static void iic_disable(unsigned int irq)
+{
+}
+
+static void iic_end(unsigned int irq)
+{
+        iic_local_enable();
+}
+
+static struct hw_interrupt_type iic_pic = {
+        .typename = " BPA-IIC  ",
+        .startup = iic_startup,
+        .enable = iic_enable,
+        .disable = iic_disable,
+        .end = iic_end,
+};
+
+static int iic_external_get_irq(struct iic_pending_bits pending)
+{
+        int irq;
+        unsigned char node, unit;
+
+        node = pending.source >> 4;
+        unit = pending.source & 0xf;
+        irq = -1;
+
+        /*
+         * This mapping is specific to the Broadband
+         * Engine. We might need to get the numbers
+         * from the device tree to support future CPUs.
+         */
+        switch (unit) {
+        case 0x00:
+        case 0x0b:
+                /*
+                 * One of these units can be connected
+                 * to an external interrupt controller.
+                 */
+                if (pending.prio > 0x3f ||
+                    pending.class != 2)
+                        break;
+                irq = IIC_EXT_OFFSET
+                        + spider_get_irq(pending.prio + node * IIC_NODE_STRIDE)
+                        + node * IIC_NODE_STRIDE;
+                break;
+        case 0x01 ... 0x04:
+        case 0x07 ... 0x0a:
+                /*
+                 * These units are connected to the SPEs
+                 */
+                if (pending.class > 2)
+                        break;
+                irq = IIC_SPE_OFFSET
+                        + pending.class * IIC_CLASS_STRIDE
+                        + node * IIC_NODE_STRIDE
+                        + unit;
+                break;
+        }
+        if (irq == -1)
+                printk(KERN_WARNING "Unexpected interrupt class %02x, "
+                        "source %02x, prio %02x, cpu %02x\n", pending.class,
+                        pending.source, pending.prio, smp_processor_id());
+        return irq;
+}
+
+/* Get an IRQ number from the pending state register of the IIC */
+int iic_get_irq(struct pt_regs *regs)
+{
+        struct iic *iic;
+        int irq;
+        struct iic_pending_bits pending;
+
+        iic = &__get_cpu_var(iic);
+        *(unsigned long *) &pending = 
+                in_be64((unsigned long __iomem *) &iic->regs->pending_destr);
+
+        irq = -1;
+        if (pending.flags & IIC_VALID) {
+                if (pending.flags & IIC_IPI) {
+                        irq = IIC_IPI_OFFSET + (pending.prio >> 4);
+/*
+                        if (irq > 0x80)
+                                printk(KERN_WARNING "Unexpected IPI prio %02x"
+                                        "on CPU %02x\n", pending.prio,
+                                                        smp_processor_id());
+*/
+                } else {
+                        irq = iic_external_get_irq(pending);
+                }
+        }
+        return irq;
+}
+
+static struct iic_regs __iomem *find_iic(int cpu)
+{
+        struct device_node *np;
+        int nodeid = cpu / 2;
+        unsigned long regs;
+        struct iic_regs __iomem *iic_regs;
+
+        for (np = of_find_node_by_type(NULL, "cpu");
+             np;
+             np = of_find_node_by_type(np, "cpu")) {
+                if (nodeid == *(int *)get_property(np, "node-id", NULL))
+                        break;
+        }
+
+        if (!np) {
+                printk(KERN_WARNING "IIC: CPU %d not found\n", cpu);
+                iic_regs = NULL;
+        } else {
+                regs = *(long *)get_property(np, "iic", NULL);
+
+                /* hack until we have decided on the devtree info */
+                regs += 0x400;
+                if (cpu & 1)
+                        regs += 0x20;
+
+                printk(KERN_DEBUG "IIC for CPU %d at %lx\n", cpu, regs);
+                iic_regs = __ioremap(regs, sizeof(struct iic_regs),
+                                                 _PAGE_NO_CACHE);
+        }
+        return iic_regs;
+}
+
+#ifdef CONFIG_SMP
+void iic_setup_cpu(void)
+{
+        out_be64(&__get_cpu_var(iic).regs->prio, 0xff);
+}
+
+void iic_cause_IPI(int cpu, int mesg)
+{
+        out_be64(&per_cpu(iic, cpu).regs->generate, mesg);
+}
+
+static irqreturn_t iic_ipi_action(int irq, void *dev_id, struct pt_regs *regs)
+{
+
+        smp_message_recv(irq - IIC_IPI_OFFSET, regs);
+        return IRQ_HANDLED;
+}
+
+static void iic_request_ipi(int irq, const char *name)
+{
+        /* IPIs are marked SA_INTERRUPT as they must run with irqs
+         * disabled */
+        get_irq_desc(irq)->handler = &iic_pic;
+        get_irq_desc(irq)->status |= IRQ_PER_CPU;
+        request_irq(irq, iic_ipi_action, SA_INTERRUPT, name, NULL);
+}
+
+void iic_request_IPIs(void)
+{
+        iic_request_ipi(IIC_IPI_OFFSET + PPC_MSG_CALL_FUNCTION, "IPI-call");
+        iic_request_ipi(IIC_IPI_OFFSET + PPC_MSG_RESCHEDULE, "IPI-resched");
+#ifdef CONFIG_DEBUGGER
+        iic_request_ipi(IIC_IPI_OFFSET + PPC_MSG_DEBUGGER_BREAK, "IPI-debug");
+#endif /* CONFIG_DEBUGGER */
+}
+#endif /* CONFIG_SMP */
+
+static void iic_setup_spe_handlers(void)
+{
+        int be, isrc;
+
+        /* Assume two threads per BE are present */
+        for (be=0; be < num_present_cpus() / 2; be++) {
+                for (isrc = 0; isrc < IIC_CLASS_STRIDE * 3; isrc++) {
+                        int irq = IIC_NODE_STRIDE * be + IIC_SPE_OFFSET + isrc;
+                        get_irq_desc(irq)->handler = &iic_pic;
+                }
+        }
+}
+
+void iic_init_IRQ(void)
+{
+        int cpu, irq_offset;
+        struct iic *iic;
+
+        irq_offset = 0;
+        for_each_cpu(cpu) {
+                iic = &per_cpu(iic, cpu);
+                iic->regs = find_iic(cpu);
+                if (iic->regs)
+                        out_be64(&iic->regs->prio, 0xff);
+        }
+        iic_setup_spe_handlers();
+}
diff --git a/arch/ppc64/kernel/bpa_iic.h b/arch/ppc64/kernel/bpa_iic.h
new file mode 100644
index 000000000000..6833c3022166
--- /dev/null
+++ b/arch/ppc64/kernel/bpa_iic.h
@@ -0,0 +1,62 @@
+#ifndef ASM_BPA_IIC_H
+#define ASM_BPA_IIC_H
+#ifdef __KERNEL__
+/*
+ * Mapping of IIC pending bits into per-node
+ * interrupt numbers.
+ *
+ * IRQ     FF CC SS PP   FF CC SS PP    Description
+ *
+ * 00-3f   80 02 +0 00 - 80 02 +0 3f    South Bridge
+ * 00-3f   80 02 +b 00 - 80 02 +b 3f    South Bridge
+ * 41-4a   80 00 +1 ** - 80 00 +a **    SPU Class 0
+ * 51-5a   80 01 +1 ** - 80 01 +a **    SPU Class 1
+ * 61-6a   80 02 +1 ** - 80 02 +a **    SPU Class 2
+ * 70-7f   C0 ** ** 00 - C0 ** ** 0f    IPI
+ *
+ *    F flags
+ *    C class
+ *    S source
+ *    P Priority
+ *    + node number
+ *    * don't care
+ *
+ * A node consists of a Broadband Engine and an optional
+ * south bridge device providing a maximum of 64 IRQs.
+ * The south bridge may be connected to either IOIF0
+ * or IOIF1.
+ * Each SPE is represented as three IRQ lines, one per
+ * interrupt class.
+ * 16 IRQ numbers are reserved for inter processor
+ * interruptions, although these are only used in the
+ * range of the first node.
+ *
+ * This scheme needs 128 IRQ numbers per BIF node ID,
+ * which means that with the total of 512 lines
+ * available, we can have a maximum of four nodes.
+ */
+
+enum {
+        IIC_EXT_OFFSET   = 0x00, /* Start of south bridge IRQs */
+        IIC_NUM_EXT      = 0x40, /* Number of south bridge IRQs */
+        IIC_SPE_OFFSET   = 0x40, /* Start of SPE interrupts */
+        IIC_CLASS_STRIDE = 0x10, /* SPE IRQs per class    */
+        IIC_IPI_OFFSET   = 0x70, /* Start of IPI IRQs */
+        IIC_NUM_IPIS     = 0x10, /* IRQs reserved for IPI */
+        IIC_NODE_STRIDE  = 0x80, /* Total IRQs per node   */
+};
+
+extern void iic_init_IRQ(void);
+extern int  iic_get_irq(struct pt_regs *regs);
+extern void iic_cause_IPI(int cpu, int mesg);
+extern void iic_request_IPIs(void);
+extern void iic_setup_cpu(void);
+extern void iic_local_enable(void);
+extern void iic_local_disable(void);
+
+
+extern void spider_init_IRQ(void);
+extern int spider_get_irq(unsigned long int_pending);
+
+#endif
+#endif /* ASM_BPA_IIC_H */
diff --git a/arch/ppc64/kernel/bpa_iommu.c b/arch/ppc64/kernel/bpa_iommu.c
new file mode 100644
index 000000000000..f33a7bccb0d7
--- /dev/null
+++ b/arch/ppc64/kernel/bpa_iommu.c
@@ -0,0 +1,377 @@
+/*
+ * IOMMU implementation for Broadband Processor Architecture
+ * We just establish a linear mapping at boot by setting all the
+ * IOPT cache entries in the CPU.
+ * The mapping functions should be identical to pci_direct_iommu, 
+ * except for the handling of the high order bit that is required
+ * by the Spider bridge. These should be split into a separate
+ * file at the point where we get a different bridge chip.
+ *
+ * Copyright (C) 2005 IBM Deutschland Entwicklung GmbH,
+ *                       Arnd Bergmann <arndb@de.ibm.com>
+ *
+ * Based on linear mapping
+ * Copyright (C) 2003 Benjamin Herrenschmidt (benh@kernel.crashing.org)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#undef DEBUG
+
+#include <linux/kernel.h>
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <linux/string.h>
+#include <linux/init.h>
+#include <linux/bootmem.h>
+#include <linux/mm.h>
+#include <linux/dma-mapping.h>
+
+#include <asm/sections.h>
+#include <asm/iommu.h>
+#include <asm/io.h>
+#include <asm/prom.h>
+#include <asm/pci-bridge.h>
+#include <asm/machdep.h>
+#include <asm/pmac_feature.h>
+#include <asm/abs_addr.h>
+#include <asm/system.h>
+
+#include "pci.h"
+#include "bpa_iommu.h"
+
+static inline unsigned long 
+get_iopt_entry(unsigned long real_address, unsigned long ioid,
+                         unsigned long prot)
+{
+        return (prot & IOPT_PROT_MASK)
+             | (IOPT_COHERENT)
+             | (IOPT_ORDER_VC)
+             | (real_address & IOPT_RPN_MASK)
+             | (ioid & IOPT_IOID_MASK);
+}
+
+typedef struct {
+        unsigned long val;
+} ioste;
+
+static inline ioste
+mk_ioste(unsigned long val)
+{
+        ioste ioste = { .val = val, };
+        return ioste;
+}
+
+static inline ioste
+get_iost_entry(unsigned long iopt_base, unsigned long io_address, unsigned page_size)
+{
+        unsigned long ps;
+        unsigned long iostep;
+        unsigned long nnpt;
+        unsigned long shift;
+
+        switch (page_size) {
+        case 0x1000000:
+                ps = IOST_PS_16M;
+                nnpt = 0;  /* one page per segment */
+                shift = 5; /* segment has 16 iopt entries */
+                break;
+
+        case 0x100000:
+                ps = IOST_PS_1M;
+                nnpt = 0;  /* one page per segment */
+                shift = 1; /* segment has 256 iopt entries */
+                break;
+
+        case 0x10000:
+                ps = IOST_PS_64K;
+                nnpt = 0x07; /* 8 pages per io page table */
+                shift = 0;   /* all entries are used */
+                break;
+
+        case 0x1000:
+                ps = IOST_PS_4K;
+                nnpt = 0x7f; /* 128 pages per io page table */
+                shift = 0;   /* all entries are used */
+                break;
+
+        default: /* not a known compile time constant */
+                BUILD_BUG_ON(1);
+                break;
+        }
+
+        iostep = iopt_base +
+                         /* need 8 bytes per iopte */
+                        (((io_address / page_size * 8)
+                         /* align io page tables on 4k page boundaries */
+                                 << shift) 
+                         /* nnpt+1 pages go into each iopt */
+                                 & ~(nnpt << 12));
+
+        nnpt++; /* this seems to work, but the documentation is not clear
+                   about wether we put nnpt or nnpt-1 into the ioste bits.
+                   In theory, this can't work for 4k pages. */
+        return mk_ioste(IOST_VALID_MASK
+                        | (iostep & IOST_PT_BASE_MASK)
+                        | ((nnpt << 5) & IOST_NNPT_MASK)
+                        | (ps & IOST_PS_MASK));
+}
+
+/* compute the address of an io pte */
+static inline unsigned long
+get_ioptep(ioste iost_entry, unsigned long io_address)
+{
+        unsigned long iopt_base;
+        unsigned long page_size;
+        unsigned long page_number;
+        unsigned long iopt_offset;
+
+        iopt_base = iost_entry.val & IOST_PT_BASE_MASK;
+        page_size = iost_entry.val & IOST_PS_MASK;
+
+        /* decode page size to compute page number */
+        page_number = (io_address & 0x0fffffff) >> (10 + 2 * page_size);
+        /* page number is an offset into the io page table */
+        iopt_offset = (page_number << 3) & 0x7fff8ul;
+        return iopt_base + iopt_offset;
+}
+
+/* compute the tag field of the iopt cache entry */
+static inline unsigned long
+get_ioc_tag(ioste iost_entry, unsigned long io_address)
+{
+        unsigned long iopte = get_ioptep(iost_entry, io_address);
+
+        return IOPT_VALID_MASK
+             | ((iopte & 0x00000000000000ff8ul) >> 3)
+             | ((iopte & 0x0000003fffffc0000ul) >> 9);
+}
+
+/* compute the hashed 6 bit index for the 4-way associative pte cache */
+static inline unsigned long
+get_ioc_hash(ioste iost_entry, unsigned long io_address)
+{
+        unsigned long iopte = get_ioptep(iost_entry, io_address);
+
+        return ((iopte & 0x000000000000001f8ul) >> 3)
+             ^ ((iopte & 0x00000000000020000ul) >> 17)
+             ^ ((iopte & 0x00000000000010000ul) >> 15)
+             ^ ((iopte & 0x00000000000008000ul) >> 13)
+             ^ ((iopte & 0x00000000000004000ul) >> 11)
+             ^ ((iopte & 0x00000000000002000ul) >> 9)
+             ^ ((iopte & 0x00000000000001000ul) >> 7);
+}
+
+/* same as above, but pretend that we have a simpler 1-way associative
+   pte cache with an 8 bit index */
+static inline unsigned long
+get_ioc_hash_1way(ioste iost_entry, unsigned long io_address)
+{
+        unsigned long iopte = get_ioptep(iost_entry, io_address);
+
+        return ((iopte & 0x000000000000001f8ul) >> 3)
+             ^ ((iopte & 0x00000000000020000ul) >> 17)
+             ^ ((iopte & 0x00000000000010000ul) >> 15)
+             ^ ((iopte & 0x00000000000008000ul) >> 13)
+             ^ ((iopte & 0x00000000000004000ul) >> 11)
+             ^ ((iopte & 0x00000000000002000ul) >> 9)
+             ^ ((iopte & 0x00000000000001000ul) >> 7)
+             ^ ((iopte & 0x0000000000000c000ul) >> 8);
+}
+
+static inline ioste
+get_iost_cache(void __iomem *base, unsigned long index)
+{
+        unsigned long __iomem *p = (base + IOC_ST_CACHE_DIR);
+        return mk_ioste(in_be64(&p[index]));
+}
+
+static inline void
+set_iost_cache(void __iomem *base, unsigned long index, ioste ste)
+{
+        unsigned long __iomem *p = (base + IOC_ST_CACHE_DIR);
+        pr_debug("ioste %02lx was %016lx, store %016lx", index,
+                        get_iost_cache(base, index).val, ste.val);
+        out_be64(&p[index], ste.val);
+        pr_debug(" now %016lx\n", get_iost_cache(base, index).val);
+}
+
+static inline unsigned long
+get_iopt_cache(void __iomem *base, unsigned long index, unsigned long *tag)
+{
+        unsigned long __iomem *tags = (void *)(base + IOC_PT_CACHE_DIR);
+        unsigned long __iomem *p = (void *)(base + IOC_PT_CACHE_REG);   
+
+        *tag = tags[index];
+        rmb();
+        return *p;
+}
+
+static inline void
+set_iopt_cache(void __iomem *base, unsigned long index,
+                 unsigned long tag, unsigned long val)
+{
+        unsigned long __iomem *tags = base + IOC_PT_CACHE_DIR;
+        unsigned long __iomem *p = base + IOC_PT_CACHE_REG;
+        pr_debug("iopt %02lx was v%016lx/t%016lx, store v%016lx/t%016lx\n",
+                index, get_iopt_cache(base, index, &oldtag), oldtag, val, tag);
+
+        out_be64(p, val);
+        out_be64(&tags[index], tag);
+}
+
+static inline void
+set_iost_origin(void __iomem *base)
+{
+        unsigned long __iomem *p = base + IOC_ST_ORIGIN;
+        unsigned long origin = IOSTO_ENABLE | IOSTO_SW;
+
+        pr_debug("iost_origin %016lx, now %016lx\n", in_be64(p), origin);
+        out_be64(p, origin);
+}
+
+static inline void
+set_iocmd_config(void __iomem *base)
+{
+        unsigned long __iomem *p = base + 0xc00;
+        unsigned long conf;
+
+        conf = in_be64(p);
+        pr_debug("iost_conf %016lx, now %016lx\n", conf, conf | IOCMD_CONF_TE);
+        out_be64(p, conf | IOCMD_CONF_TE);
+}
+
+/* FIXME: get these from the device tree */
+#define ioc_base        0x20000511000ull
+#define ioc_mmio_base   0x20000510000ull
+#define ioid            0x48a
+#define iopt_phys_offset (- 0x20000000) /* We have a 512MB offset from the SB */
+#define io_page_size    0x1000000
+
+static unsigned long map_iopt_entry(unsigned long address)
+{
+        switch (address >> 20) {
+        case 0x600:
+                address = 0x24020000000ull; /* spider i/o */
+                break;
+        default:
+                address += iopt_phys_offset;
+                break;
+        }
+
+        return get_iopt_entry(address, ioid, IOPT_PROT_RW);
+}
+
+static void iommu_bus_setup_null(struct pci_bus *b) { }
+static void iommu_dev_setup_null(struct pci_dev *d) { }
+
+/* initialize the iommu to support a simple linear mapping
+ * for each DMA window used by any device. For now, we
+ * happen to know that there is only one DMA window in use,
+ * starting at iopt_phys_offset. */
+static void bpa_map_iommu(void)
+{
+        unsigned long address;
+        void __iomem *base;
+        ioste ioste;
+        unsigned long index;
+
+        base = __ioremap(ioc_base, 0x1000, _PAGE_NO_CACHE);
+        pr_debug("%lx mapped to %p\n", ioc_base, base);
+        set_iocmd_config(base);
+        iounmap(base);
+
+        base = __ioremap(ioc_mmio_base, 0x1000, _PAGE_NO_CACHE);
+        pr_debug("%lx mapped to %p\n", ioc_mmio_base, base);
+
+        set_iost_origin(base);
+
+        for (address = 0; address < 0x100000000ul; address += io_page_size) {
+                ioste = get_iost_entry(0x10000000000ul, address, io_page_size);
+                if ((address & 0xfffffff) == 0) /* segment start */
+                        set_iost_cache(base, address >> 28, ioste);
+                index = get_ioc_hash_1way(ioste, address);
+                pr_debug("addr %08lx, index %02lx, ioste %016lx\n",
+                                         address, index, ioste.val);
+                set_iopt_cache(base,
+                        get_ioc_hash_1way(ioste, address),
+                        get_ioc_tag(ioste, address),
+                        map_iopt_entry(address));
+        }
+        iounmap(base);
+}
+
+
+static void *bpa_alloc_coherent(struct device *hwdev, size_t size,
+                           dma_addr_t *dma_handle, unsigned int __nocast flag)
+{
+        void *ret;
+
+        ret = (void *)__get_free_pages(flag, get_order(size));
+        if (ret != NULL) {
+                memset(ret, 0, size);
+                *dma_handle = virt_to_abs(ret) | BPA_DMA_VALID;
+        }
+        return ret;
+}
+
+static void bpa_free_coherent(struct device *hwdev, size_t size,
+                                 void *vaddr, dma_addr_t dma_handle)
+{
+        free_pages((unsigned long)vaddr, get_order(size));
+}
+
+static dma_addr_t bpa_map_single(struct device *hwdev, void *ptr,
+                size_t size, enum dma_data_direction direction)
+{
+        return virt_to_abs(ptr) | BPA_DMA_VALID;
+}
+
+static void bpa_unmap_single(struct device *hwdev, dma_addr_t dma_addr,
+                size_t size, enum dma_data_direction direction)
+{
+}
+
+static int bpa_map_sg(struct device *hwdev, struct scatterlist *sg,
+                int nents, enum dma_data_direction direction)
+{
+        int i;
+
+        for (i = 0; i < nents; i++, sg++) {
+                sg->dma_address = (page_to_phys(sg->page) + sg->offset)
+                                        | BPA_DMA_VALID;
+                sg->dma_length = sg->length;
+        }
+
+        return nents;
+}
+
+static void bpa_unmap_sg(struct device *hwdev, struct scatterlist *sg,
+                int nents, enum dma_data_direction direction)
+{
+}
+
+static int bpa_dma_supported(struct device *dev, u64 mask)
+{
+        return mask < 0x100000000ull;
+}
+
+void bpa_init_iommu(void)
+{
+        bpa_map_iommu();
+
+        /* Direct I/O, IOMMU off */
+        ppc_md.iommu_dev_setup = iommu_dev_setup_null;
+        ppc_md.iommu_bus_setup = iommu_bus_setup_null;
+
+        pci_dma_ops.alloc_coherent = bpa_alloc_coherent;
+        pci_dma_ops.free_coherent = bpa_free_coherent;
+        pci_dma_ops.map_single = bpa_map_single;
+        pci_dma_ops.unmap_single = bpa_unmap_single;
+        pci_dma_ops.map_sg = bpa_map_sg;
+        pci_dma_ops.unmap_sg = bpa_unmap_sg;
+        pci_dma_ops.dma_supported = bpa_dma_supported;
+}
diff --git a/arch/ppc64/kernel/bpa_iommu.h b/arch/ppc64/kernel/bpa_iommu.h
new file mode 100644
index 000000000000..e547d77dfa04
--- /dev/null
+++ b/arch/ppc64/kernel/bpa_iommu.h
@@ -0,0 +1,65 @@
+#ifndef BPA_IOMMU_H
+#define BPA_IOMMU_H
+
+/* some constants */
+enum {
+        /* segment table entries */
+        IOST_VALID_MASK   = 0x8000000000000000ul,
+        IOST_TAG_MASK     = 0x3000000000000000ul,
+        IOST_PT_BASE_MASK = 0x000003fffffff000ul,
+        IOST_NNPT_MASK    = 0x0000000000000fe0ul,
+        IOST_PS_MASK      = 0x000000000000000ful,
+
+        IOST_PS_4K        = 0x1,
+        IOST_PS_64K       = 0x3,
+        IOST_PS_1M        = 0x5,
+        IOST_PS_16M       = 0x7,
+
+        /* iopt tag register */
+        IOPT_VALID_MASK   = 0x0000000200000000ul,
+        IOPT_TAG_MASK     = 0x00000001fffffffful,
+
+        /* iopt cache register */
+        IOPT_PROT_MASK    = 0xc000000000000000ul,
+        IOPT_PROT_NONE    = 0x0000000000000000ul,
+        IOPT_PROT_READ    = 0x4000000000000000ul,
+        IOPT_PROT_WRITE   = 0x8000000000000000ul,
+        IOPT_PROT_RW      = 0xc000000000000000ul,
+        IOPT_COHERENT     = 0x2000000000000000ul,
+        
+        IOPT_ORDER_MASK   = 0x1800000000000000ul,
+        /* order access to same IOID/VC on same address */
+        IOPT_ORDER_ADDR   = 0x0800000000000000ul,
+        /* similar, but only after a write access */
+        IOPT_ORDER_WRITES = 0x1000000000000000ul,
+        /* Order all accesses to same IOID/VC */
+        IOPT_ORDER_VC     = 0x1800000000000000ul,
+        
+        IOPT_RPN_MASK     = 0x000003fffffff000ul,
+        IOPT_HINT_MASK    = 0x0000000000000800ul,
+        IOPT_IOID_MASK    = 0x00000000000007fful,
+
+        IOSTO_ENABLE      = 0x8000000000000000ul,
+        IOSTO_ORIGIN      = 0x000003fffffff000ul,
+        IOSTO_HW          = 0x0000000000000800ul,
+        IOSTO_SW          = 0x0000000000000400ul,
+
+        IOCMD_CONF_TE     = 0x0000800000000000ul,
+
+        /* memory mapped registers */
+        IOC_PT_CACHE_DIR  = 0x000,
+        IOC_ST_CACHE_DIR  = 0x800,
+        IOC_PT_CACHE_REG  = 0x910,
+        IOC_ST_ORIGIN     = 0x918,
+        IOC_CONF          = 0x930,
+
+        /* The high bit needs to be set on every DMA address,
+           only 2GB are addressable */
+        BPA_DMA_VALID     = 0x80000000,
+        BPA_DMA_MASK      = 0x7fffffff,
+};
+
+
+void bpa_init_iommu(void);
+
+#endif
diff --git a/arch/ppc64/kernel/bpa_nvram.c b/arch/ppc64/kernel/bpa_nvram.c
new file mode 100644
index 000000000000..06a119cfceb5
--- /dev/null
+++ b/arch/ppc64/kernel/bpa_nvram.c
@@ -0,0 +1,118 @@
+/*
+ * NVRAM for CPBW
+ *
+ * (C) Copyright IBM Corp. 2005
+ *
+ * Authors : Utz Bacher <utz.bacher@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/fs.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+#include <linux/types.h>
+
+#include <asm/machdep.h>
+#include <asm/nvram.h>
+#include <asm/prom.h>
+
+static void __iomem *bpa_nvram_start;
+static long bpa_nvram_len;
+static spinlock_t bpa_nvram_lock = SPIN_LOCK_UNLOCKED;
+
+static ssize_t bpa_nvram_read(char *buf, size_t count, loff_t *index)
+{
+        unsigned long flags;
+
+        if (*index >= bpa_nvram_len)
+                return 0;
+        if (*index + count > bpa_nvram_len)
+                count = bpa_nvram_len - *index;
+
+        spin_lock_irqsave(&bpa_nvram_lock, flags);
+
+        memcpy_fromio(buf, bpa_nvram_start + *index, count);
+
+        spin_unlock_irqrestore(&bpa_nvram_lock, flags);
+        
+        *index += count;
+        return count;
+}
+
+static ssize_t bpa_nvram_write(char *buf, size_t count, loff_t *index)
+{
+        unsigned long flags;
+
+        if (*index >= bpa_nvram_len)
+                return 0;
+        if (*index + count > bpa_nvram_len)
+                count = bpa_nvram_len - *index;
+
+        spin_lock_irqsave(&bpa_nvram_lock, flags);
+
+        memcpy_toio(bpa_nvram_start + *index, buf, count);
+
+        spin_unlock_irqrestore(&bpa_nvram_lock, flags);
+        
+        *index += count;
+        return count;
+}
+
+static ssize_t bpa_nvram_get_size(void)
+{
+        return bpa_nvram_len;
+}
+
+int __init bpa_nvram_init(void)
+{
+        struct device_node *nvram_node;
+        unsigned long *buffer;
+        int proplen;
+        unsigned long nvram_addr;
+        int ret;
+
+        ret = -ENODEV;
+        nvram_node = of_find_node_by_type(NULL, "nvram");
+        if (!nvram_node)
+                goto out;
+
+        ret = -EIO;
+        buffer = (unsigned long *)get_property(nvram_node, "reg", &proplen);
+        if (proplen != 2*sizeof(unsigned long))
+                goto out;
+
+        ret = -ENODEV;
+        nvram_addr = buffer[0];
+        bpa_nvram_len = buffer[1];
+        if ( (!bpa_nvram_len) || (!nvram_addr) )
+                goto out;
+
+        bpa_nvram_start = ioremap(nvram_addr, bpa_nvram_len);
+        if (!bpa_nvram_start)
+                goto out;
+
+        printk(KERN_INFO "BPA NVRAM, %luk mapped to %p\n",
+               bpa_nvram_len >> 10, bpa_nvram_start);
+
+        ppc_md.nvram_read       = bpa_nvram_read;
+        ppc_md.nvram_write      = bpa_nvram_write;
+        ppc_md.nvram_size       = bpa_nvram_get_size;
+
+out:
+        of_node_put(nvram_node);
+        return ret;
+}
diff --git a/arch/ppc64/kernel/bpa_setup.c b/arch/ppc64/kernel/bpa_setup.c
new file mode 100644
index 000000000000..57b3db66f458
--- /dev/null
+++ b/arch/ppc64/kernel/bpa_setup.c
@@ -0,0 +1,140 @@
+/*
+ *  linux/arch/ppc/kernel/bpa_setup.c
+ *
+ *  Copyright (C) 1995  Linus Torvalds
+ *  Adapted from 'alpha' version by Gary Thomas
+ *  Modified by Cort Dougan (cort@cs.nmt.edu)
+ *  Modified by PPC64 Team, IBM Corp
+ *  Modified by BPA Team, IBM Deutschland Entwicklung GmbH
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+#undef DEBUG
+
+#include <linux/config.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/stddef.h>
+#include <linux/unistd.h>
+#include <linux/slab.h>
+#include <linux/user.h>
+#include <linux/reboot.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/irq.h>
+#include <linux/seq_file.h>
+#include <linux/root_dev.h>
+#include <linux/console.h>
+
+#include <asm/mmu.h>
+#include <asm/processor.h>
+#include <asm/io.h>
+#include <asm/pgtable.h>
+#include <asm/prom.h>
+#include <asm/rtas.h>
+#include <asm/pci-bridge.h>
+#include <asm/iommu.h>
+#include <asm/dma.h>
+#include <asm/machdep.h>
+#include <asm/time.h>
+#include <asm/nvram.h>
+#include <asm/cputable.h>
+
+#include "pci.h"
+#include "bpa_iic.h"
+#include "bpa_iommu.h"
+
+#ifdef DEBUG
+#define DBG(fmt...) udbg_printf(fmt)
+#else
+#define DBG(fmt...)
+#endif
+
+void bpa_get_cpuinfo(struct seq_file *m)
+{
+        struct device_node *root;
+        const char *model = "";
+
+        root = of_find_node_by_path("/");
+        if (root)
+                model = get_property(root, "model", NULL);
+        seq_printf(m, "machine\t\t: BPA %s\n", model);
+        of_node_put(root);
+}
+
+static void bpa_progress(char *s, unsigned short hex)
+{
+        printk("*** %04x : %s\n", hex, s ? s : "");
+}
+
+static void __init bpa_setup_arch(void)
+{
+        ppc_md.init_IRQ       = iic_init_IRQ;
+        ppc_md.get_irq        = iic_get_irq;
+
+#ifdef CONFIG_SMP
+        smp_init_pSeries();
+#endif
+
+        /* init to some ~sane value until calibrate_delay() runs */
+        loops_per_jiffy = 50000000;
+
+        if (ROOT_DEV == 0) {
+                printk("No ramdisk, default root is /dev/hda2\n");
+                ROOT_DEV = Root_HDA2;
+        }
+
+        /* Find and initialize PCI host bridges */
+        init_pci_config_tokens();
+        find_and_init_phbs();
+        spider_init_IRQ();
+#ifdef CONFIG_DUMMY_CONSOLE
+        conswitchp = &dummy_con;
+#endif
+
+        bpa_nvram_init();
+}
+
+/*
+ * Early initialization.  Relocation is on but do not reference unbolted pages
+ */
+static void __init bpa_init_early(void)
+{
+        DBG(" -> bpa_init_early()\n");
+
+        hpte_init_native();
+
+        bpa_init_iommu();
+
+        ppc64_interrupt_controller = IC_BPA_IIC;
+
+        DBG(" <- bpa_init_early()\n");
+}
+
+
+static int __init bpa_probe(int platform)
+{
+        if (platform != PLATFORM_BPA)
+                return 0;
+
+        return 1;
+}
+
+struct machdep_calls __initdata bpa_md = {
+        .probe                  = bpa_probe,
+        .setup_arch             = bpa_setup_arch,
+        .init_early             = bpa_init_early,
+        .get_cpuinfo            = bpa_get_cpuinfo,
+        .restart                = rtas_restart,
+        .power_off              = rtas_power_off,
+        .halt                   = rtas_halt,
+        .get_boot_time          = rtas_get_boot_time,
+        .get_rtc_time           = rtas_get_rtc_time,
+        .set_rtc_time           = rtas_set_rtc_time,
+        .calibrate_decr         = generic_calibrate_decr,
+        .progress               = bpa_progress,
+};
diff --git a/arch/ppc64/kernel/cpu_setup_power4.S b/arch/ppc64/kernel/cpu_setup_power4.S
index 3bd951820850..42fc08cf87a0 100644
--- a/arch/ppc64/kernel/cpu_setup_power4.S
+++ b/arch/ppc64/kernel/cpu_setup_power4.S
@@ -73,7 +73,21 @@ _GLOBAL(__970_cpu_preinit)
 
 _GLOBAL(__setup_cpu_power4)
         blr
-        
+
+_GLOBAL(__setup_cpu_be)
+        /* Set large page sizes LP=0: 16MB, LP=1: 64KB */
+        addi    r3, 0,  0
+        ori     r3, r3, HID6_LB
+        sldi    r3, r3, 32
+        nor     r3, r3, r3
+        mfspr   r4, SPRN_HID6
+        and     r4, r4, r3
+        addi    r3, 0, 0x02000
+        sldi    r3, r3, 32
+        or      r4, r4, r3
+        mtspr   SPRN_HID6, r4
+        blr
+
 _GLOBAL(__setup_cpu_ppc970)
         mfspr   r0,SPRN_HID0
         li      r11,5                   /* clear DOZE and SLEEP */
diff --git a/arch/ppc64/kernel/cputable.c b/arch/ppc64/kernel/cputable.c
index 8644a8648058..1d162c7c59df 100644
--- a/arch/ppc64/kernel/cputable.c
+++ b/arch/ppc64/kernel/cputable.c
@@ -34,6 +34,7 @@ EXPORT_SYMBOL(cur_cpu_spec);
 extern void __setup_cpu_power3(unsigned long offset, struct cpu_spec* spec);
 extern void __setup_cpu_power4(unsigned long offset, struct cpu_spec* spec);
 extern void __setup_cpu_ppc970(unsigned long offset, struct cpu_spec* spec);
+extern void __setup_cpu_be(unsigned long offset, struct cpu_spec* spec);
 
 
 /* We only set the altivec features if the kernel was compiled with altivec
@@ -162,6 +163,16 @@ struct cpu_spec	cpu_specs[] = {
             __setup_cpu_power4,
             COMMON_PPC64_FW
     },
+    {   /* BE DD1.x  */
+            0xffff0000, 0x00700000, "Broadband Engine",
+            CPU_FTR_SPLIT_ID_CACHE | CPU_FTR_USE_TB | CPU_FTR_HPTE_TABLE |
+                    CPU_FTR_PPCAS_ARCH_V2 | CPU_FTR_ALTIVEC_COMP |
+                    CPU_FTR_SMT,
+            COMMON_USER_PPC64 | PPC_FEATURE_HAS_ALTIVEC_COMP,
+            128, 128,
+            __setup_cpu_be,
+            COMMON_PPC64_FW
+    },
     {   /* default match */
             0x00000000, 0x00000000, "POWER4 (compatible)",
             CPU_FTR_SPLIT_ID_CACHE | CPU_FTR_USE_TB | CPU_FTR_HPTE_TABLE |
diff --git a/arch/ppc64/kernel/dma.c b/arch/ppc64/kernel/dma.c
index ce714c927134..4da8e31b2b61 100644
--- a/arch/ppc64/kernel/dma.c
+++ b/arch/ppc64/kernel/dma.c
@@ -15,8 +15,10 @@
 
 static struct dma_mapping_ops *get_dma_ops(struct device *dev)
 {
+#ifdef CONFIG_PCI
         if (dev->bus == &pci_bus_type)
                 return &pci_dma_ops;
+#endif
 #ifdef CONFIG_IBMVIO
         if (dev->bus == &vio_bus_type)
                 return &vio_dma_ops;
@@ -37,8 +39,10 @@ EXPORT_SYMBOL(dma_supported);
 
 int dma_set_mask(struct device *dev, u64 dma_mask)
 {
+#ifdef CONFIG_PCI
         if (dev->bus == &pci_bus_type)
                 return pci_set_dma_mask(to_pci_dev(dev), dma_mask);
+#endif
 #ifdef CONFIG_IBMVIO
         if (dev->bus == &vio_bus_type)
                 return -EIO;
diff --git a/arch/ppc64/kernel/eeh.c b/arch/ppc64/kernel/eeh.c
index d63d41f3eecf..af5272fedadf 100644
--- a/arch/ppc64/kernel/eeh.c
+++ b/arch/ppc64/kernel/eeh.c
@@ -505,7 +505,7 @@ static inline unsigned long eeh_token_to_phys(unsigned long token)
         pte_t *ptep;
         unsigned long pa;
 
-        ptep = find_linux_pte(ioremap_mm.pgd, token);
+        ptep = find_linux_pte(init_mm.pgd, token);
         if (!ptep)
                 return token;
         pa = pte_pfn(*ptep) << PAGE_SHIFT;
diff --git a/arch/ppc64/kernel/head.S b/arch/ppc64/kernel/head.S
index 346dbf606b5d..675c2708588f 100644
--- a/arch/ppc64/kernel/head.S
+++ b/arch/ppc64/kernel/head.S
@@ -1194,7 +1194,7 @@ _GLOBAL(pSeries_secondary_smp_init)
         bl      .__restore_cpu_setup
 
         /* Set up a paca value for this processor. Since we have the
-         * physical cpu id in r3, we need to search the pacas to find
+         * physical cpu id in r24, we need to search the pacas to find
          * which logical id maps to our physical one.
          */
         LOADADDR(r13, paca)             /* Get base vaddr of paca array  */
@@ -1207,8 +1207,8 @@ _GLOBAL(pSeries_secondary_smp_init)
         cmpwi   r5,NR_CPUS
         blt     1b
 
-99:     HMT_LOW                         /* Couldn't find our CPU id      */
-        b       99b
+        mr      r3,r24                  /* not found, copy phys to r3    */
+        b       .kexec_wait             /* next kernel might do better   */
 
 2:      mtspr   SPRG3,r13               /* Save vaddr of paca in SPRG3   */
         /* From now on, r24 is expected to be logica cpuid */
@@ -2121,10 +2121,6 @@ empty_zero_page:
 swapper_pg_dir:
         .space  4096
 
-        .globl  ioremap_dir
-ioremap_dir:
-        .space  4096
-
 #ifdef CONFIG_SMP
 /* 1 page segment table per cpu (max 48, cpu0 allocated at STAB0_PHYS_ADDR) */
         .globl  stab_array
diff --git a/arch/ppc64/kernel/iSeries_VpdInfo.c b/arch/ppc64/kernel/iSeries_VpdInfo.c
index a6f0ff2d0239..d11c732daf81 100644
--- a/arch/ppc64/kernel/iSeries_VpdInfo.c
+++ b/arch/ppc64/kernel/iSeries_VpdInfo.c
@@ -1,31 +1,31 @@
-/************************************************************************/
-/* File iSeries_vpdInfo.c created by Allan Trautman on Fri Feb  2 2001. */
-/************************************************************************/
-/* This code gets the card location of the hardware                     */
-/* Copyright (C) 20yy  <Allan H Trautman> <IBM Corp>                    */
-/*                                                                      */
-/* This program is free software; you can redistribute it and/or modify */
-/* it under the terms of the GNU General Public License as published by */
-/* the Free Software Foundation; either version 2 of the License, or    */
-/* (at your option) any later version.                                  */
-/*                                                                      */
-/* This program is distributed in the hope that it will be useful,      */ 
-/* but WITHOUT ANY WARRANTY; without even the implied warranty of       */
-/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        */
-/* GNU General Public License for more details.                         */
-/*                                                                      */
-/* You should have received a copy of the GNU General Public License    */ 
-/* along with this program; if not, write to the:                       */
-/* Free Software Foundation, Inc.,                                      */ 
-/* 59 Temple Place, Suite 330,                                          */ 
-/* Boston, MA  02111-1307  USA                                          */
-/************************************************************************/
-/* Change Activity:                                                     */
-/*   Created, Feb 2, 2001                                               */
-/*   Ported to ppc64, August 20, 2001                                   */
-/* End Change Activity                                                  */
-/************************************************************************/
-#include <linux/config.h>
+/*
+ * File iSeries_vpdInfo.c created by Allan Trautman on Fri Feb  2 2001.
+ *
+ * This code gets the card location of the hardware
+ * Copyright (C) 2001  <Allan H Trautman> <IBM Corp>
+ * Copyright (C) 2005  Stephen Rothwel, IBM Corp
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the:
+ * Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330,
+ * Boston, MA  02111-1307  USA
+ *
+ * Change Activity:
+ *   Created, Feb 2, 2001
+ *   Ported to ppc64, August 20, 2001
+ * End Change Activity
+ */
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/pci.h>
@@ -34,30 +34,25 @@
 
 #include <asm/iSeries/HvCallPci.h>
 #include <asm/iSeries/HvTypes.h>
-#include <asm/iSeries/mf.h>
-#include <asm/iSeries/LparData.h>
 #include <asm/iSeries/iSeries_pci.h>
-#include "pci.h"
 
 /*
  * Size of Bus VPD data
  */
 #define BUS_VPDSIZE      1024
+
 /*
  * Bus Vpd Tags
  */
-#define  VpdEndOfDataTag   0x78
 #define  VpdEndOfAreaTag   0x79
 #define  VpdIdStringTag    0x82
 #define  VpdVendorAreaTag  0x84
+
 /*
  * Mfg Area Tags
  */
-#define  VpdFruFlag       0x4647     // "FG"
 #define  VpdFruFrameId    0x4649     // "FI"
 #define  VpdSlotMapFormat 0x4D46     // "MF"
-#define  VpdAsmPartNumber 0x504E     // "PN"
-#define  VpdFruSerial     0x534E     // "SN"
 #define  VpdSlotMap       0x534D     // "SM"
 
 /*
@@ -79,74 +74,33 @@ struct SlotMapStruct {
         char CardLocation[3];
         char Parms[8];
         char Reserved[2];
-}; 
+};
 typedef struct SlotMapStruct SlotMap;
 #define SLOT_ENTRY_SIZE   16
 
 /*
- * Formats the device information.
- * - Pass in pci_dev* pointer to the device.
- * - Pass in buffer to place the data.  Danger here is the buffer must
- *   be as big as the client says it is.   Should be at least 128 bytes.
- * Return will the length of the string data put in the buffer.
- * Format:
- * PCI: Bus  0, Device 26, Vendor 0x12AE  Frame  1, Card  C10  Ethernet
- * controller
- */
-int iSeries_Device_Information(struct pci_dev *PciDev, char *buffer,
-                int BufferSize)
-{
-        struct iSeries_Device_Node *DevNode =
-                (struct iSeries_Device_Node *)PciDev->sysdata;
-        int len;
-
-        if (DevNode == NULL)
-                return sprintf(buffer,
-                                "PCI: iSeries_Device_Information DevNode is NULL");
-
-        if (BufferSize < 128)
-                return 0;
-
-        len = sprintf(buffer, "PCI: Bus%3d, Device%3d, Vendor %04X ",
-                        ISERIES_BUS(DevNode), PCI_SLOT(PciDev->devfn),
-                        PciDev->vendor);
-        len += sprintf(buffer + len, "Frame%3d, Card %4s  ",
-                        DevNode->FrameId, DevNode->CardLocation);
-#ifdef CONFIG_PCI
-        if (pci_class_name(PciDev->class >> 8) == 0)
-                len += sprintf(buffer + len, "0x%04X  ",
-                                (int)(PciDev->class >> 8));
-        else
-                len += sprintf(buffer + len, "%s",
-                                pci_class_name(PciDev->class >> 8));
-#endif
-        return len;
-}
-
-/*
  * Parse the Slot Area
  */
-void iSeries_Parse_SlotArea(SlotMap *MapPtr, int MapLen,
-                struct iSeries_Device_Node *DevNode)
+static void __init iSeries_Parse_SlotArea(SlotMap *MapPtr, int MapLen,
+                HvAgentId agent, u8 *PhbId, char card[4])
 {
         int SlotMapLen = MapLen;
         SlotMap *SlotMapPtr = MapPtr;
 
         /*
-         * Parse Slot label until we find the one requrested
+         * Parse Slot label until we find the one requested
          */
         while (SlotMapLen > 0) {
-                if (SlotMapPtr->AgentId == DevNode->AgentId ) {
+                if (SlotMapPtr->AgentId == agent) {
                         /*
                          * If Phb wasn't found, grab the entry first one found.
                          */
-                        if (DevNode->PhbId == 0xff)
-                                DevNode->PhbId = SlotMapPtr->PhbId; 
+                        if (*PhbId == 0xff)
+                                *PhbId = SlotMapPtr->PhbId;
                         /* Found it, extract the data. */
-                        if (SlotMapPtr->PhbId == DevNode->PhbId ) {
-                                memcpy(&DevNode->CardLocation,
-                                                &SlotMapPtr->CardLocation, 3);
-                                DevNode->CardLocation[3]  = 0;
+                        if (SlotMapPtr->PhbId == *PhbId) {
+                                memcpy(card, &SlotMapPtr->CardLocation, 3);
+                                card[3]  = 0;
                                 break;
                         }
                 }
@@ -159,8 +113,9 @@ void iSeries_Parse_SlotArea(SlotMap *MapPtr, int MapLen,
 /*
  * Parse the Mfg Area
  */
-static void iSeries_Parse_MfgArea(u8 *AreaData, int AreaLen,
-                struct iSeries_Device_Node *DevNode)
+static void __init iSeries_Parse_MfgArea(u8 *AreaData, int AreaLen,
+                HvAgentId agent, u8 *PhbId,
+                u8 *frame, char card[4])
 {
         MfgArea *MfgAreaPtr = (MfgArea *)AreaData;
         int MfgAreaLen = AreaLen;
@@ -171,7 +126,7 @@ static void iSeries_Parse_MfgArea(u8 *AreaData, int AreaLen,
                 int MfgTagLen = MfgAreaPtr->TagLength;
                 /* Frame ID         (FI 4649020310 ) */
                 if (MfgAreaPtr->Tag == VpdFruFrameId)           /* FI  */
-                        DevNode->FrameId = MfgAreaPtr->AreaData1;
+                        *frame = MfgAreaPtr->AreaData1;
                 /* Slot Map Format  (MF 4D46020004 ) */
                 else if (MfgAreaPtr->Tag == VpdSlotMapFormat)   /* MF  */
                         SlotMapFmt = (MfgAreaPtr->AreaData1 * 256)
@@ -183,10 +138,11 @@ static void iSeries_Parse_MfgArea(u8 *AreaData, int AreaLen,
                         if (SlotMapFmt == 0x1004)
                                 SlotMapPtr = (SlotMap *)((char *)MfgAreaPtr
                                                 + MFG_ENTRY_SIZE + 1);
-                        else
+                        else
                                 SlotMapPtr = (SlotMap *)((char *)MfgAreaPtr
                                                 + MFG_ENTRY_SIZE);
-                        iSeries_Parse_SlotArea(SlotMapPtr, MfgTagLen, DevNode);
+                        iSeries_Parse_SlotArea(SlotMapPtr, MfgTagLen,
+                                        agent, PhbId, card);
                 }
                 /*
                  * Point to the next Mfg Area
@@ -194,19 +150,19 @@ static void iSeries_Parse_MfgArea(u8 *AreaData, int AreaLen,
                  */
                 MfgAreaPtr = (MfgArea *)((char *)MfgAreaPtr + MfgTagLen
                                 + MFG_ENTRY_SIZE);
-                MfgAreaLen -= (MfgTagLen + MFG_ENTRY_SIZE); 
-        }       
+                MfgAreaLen -= (MfgTagLen + MFG_ENTRY_SIZE);
+        }
 }
 
 /*
  * Look for "BUS".. Data is not Null terminated.
  * PHBID of 0xFF indicates PHB was not found in VPD Data.
  */
-static int iSeries_Parse_PhbId(u8 *AreaPtr, int AreaLength)
+static int __init iSeries_Parse_PhbId(u8 *AreaPtr, int AreaLength)
 {
         u8 *PhbPtr = AreaPtr;
         int DataLen = AreaLength;
-        char PhbId = 0xFF;                   
+        char PhbId = 0xFF;
 
         while (DataLen > 0) {
                 if ((*PhbPtr == 'B') && (*(PhbPtr + 1) == 'U')
@@ -216,7 +172,7 @@ static int iSeries_Parse_PhbId(u8 *AreaPtr, int AreaLength)
                                 ++PhbPtr;
                         PhbId = (*PhbPtr & 0x0F);
                         break;
-                }
+                }
                 ++PhbPtr;
                 --DataLen;
         }
@@ -226,52 +182,90 @@ static int iSeries_Parse_PhbId(u8 *AreaPtr, int AreaLength)
 /*
  * Parse out the VPD Areas
  */
-static void iSeries_Parse_Vpd(u8 *VpdData, int VpdDataLen,
-                struct iSeries_Device_Node *DevNode)
+static void __init iSeries_Parse_Vpd(u8 *VpdData, int VpdDataLen,
+                HvAgentId agent, u8 *frame, char card[4])
 {
         u8 *TagPtr = VpdData;
         int DataLen = VpdDataLen - 3;
+        u8 PhbId;
 
         while ((*TagPtr != VpdEndOfAreaTag) && (DataLen > 0)) {
-                int AreaLen = *(TagPtr + 1) + (*(TagPtr + 2) * 256);    
+                int AreaLen = *(TagPtr + 1) + (*(TagPtr + 2) * 256);
                 u8 *AreaData  = TagPtr + 3;
 
                 if (*TagPtr == VpdIdStringTag)
-                        DevNode->PhbId = iSeries_Parse_PhbId(AreaData, AreaLen);
+                        PhbId = iSeries_Parse_PhbId(AreaData, AreaLen);
                 else if (*TagPtr == VpdVendorAreaTag)
-                        iSeries_Parse_MfgArea(AreaData, AreaLen, DevNode);
+                        iSeries_Parse_MfgArea(AreaData, AreaLen,
+                                        agent, &PhbId, frame, card);
                 /* Point to next Area. */
                 TagPtr  = AreaData + AreaLen;
                 DataLen -= AreaLen;
         }
-}    
+}
 
-void iSeries_Get_Location_Code(struct iSeries_Device_Node *DevNode)
+static void __init iSeries_Get_Location_Code(u16 bus, HvAgentId agent,
+                u8 *frame, char card[4])
 {
         int BusVpdLen = 0;
-        u8 *BusVpdPtr = (u8 *)kmalloc(BUS_VPDSIZE, GFP_KERNEL);
+        u8 *BusVpdPtr = kmalloc(BUS_VPDSIZE, GFP_KERNEL);
 
         if (BusVpdPtr == NULL) {
                 printk("PCI: Bus VPD Buffer allocation failure.\n");
                 return;
         }
-        BusVpdLen = HvCallPci_getBusVpd(ISERIES_BUS(DevNode),
-                                        ISERIES_HV_ADDR(BusVpdPtr),
+        BusVpdLen = HvCallPci_getBusVpd(bus, ISERIES_HV_ADDR(BusVpdPtr),
                                         BUS_VPDSIZE);
         if (BusVpdLen == 0) {
-                kfree(BusVpdPtr);
                 printk("PCI: Bus VPD Buffer zero length.\n");
-                return;
+                goto out_free;
         }
         /* printk("PCI: BusVpdPtr: %p, %d\n",BusVpdPtr, BusVpdLen); */
         /* Make sure this is what I think it is */
         if (*BusVpdPtr != VpdIdStringTag) {     /* 0x82 */
                 printk("PCI: Bus VPD Buffer missing starting tag.\n");
-                kfree(BusVpdPtr);
-                return;
+                goto out_free;
         }
-        iSeries_Parse_Vpd(BusVpdPtr,BusVpdLen, DevNode);
-        sprintf(DevNode->Location, "Frame%3d, Card %-4s", DevNode->FrameId,
-                        DevNode->CardLocation);
+        iSeries_Parse_Vpd(BusVpdPtr, BusVpdLen, agent, frame, card);
+out_free:
         kfree(BusVpdPtr);
 }
+
+/*
+ * Prints the device information.
+ * - Pass in pci_dev* pointer to the device.
+ * - Pass in the device count
+ *
+ * Format:
+ * PCI: Bus  0, Device 26, Vendor 0x12AE  Frame  1, Card  C10  Ethernet
+ * controller
+ */
+void __init iSeries_Device_Information(struct pci_dev *PciDev, int count)
+{
+        struct iSeries_Device_Node *DevNode = PciDev->sysdata;
+        u16 bus;
+        u8 frame;
+        char card[4];
+        HvSubBusNumber subbus;
+        HvAgentId agent;
+
+        if (DevNode == NULL) {
+                printk("%d. PCI: iSeries_Device_Information DevNode is NULL\n",
+                                count);
+                return;
+        }
+
+        bus = ISERIES_BUS(DevNode);
+        subbus = ISERIES_SUBBUS(DevNode);
+        agent = ISERIES_PCI_AGENTID(ISERIES_GET_DEVICE_FROM_SUBBUS(subbus),
+                        ISERIES_GET_FUNCTION_FROM_SUBBUS(subbus));
+        iSeries_Get_Location_Code(bus, agent, &frame, card);
+
+        printk("%d. PCI: Bus%3d, Device%3d, Vendor %04X Frame%3d, Card %4s  ",
+                        count, bus, PCI_SLOT(PciDev->devfn), PciDev->vendor,
+                        frame, card);
+        if (pci_class_name(PciDev->class >> 8) == 0)
+                printk("0x%04X\n", (int)(PciDev->class >> 8));
+        else
+                printk("%s\n", pci_class_name(PciDev->class >> 8));
+}
diff --git a/arch/ppc64/kernel/iSeries_iommu.c b/arch/ppc64/kernel/iSeries_iommu.c
index 4e1a47c8a802..f8ff1bb054dc 100644
--- a/arch/ppc64/kernel/iSeries_iommu.c
+++ b/arch/ppc64/kernel/iSeries_iommu.c
@@ -83,7 +83,7 @@ static void tce_free_iSeries(struct iommu_table *tbl, long index, long npages)
         }
 }
 
-
+#ifdef CONFIG_PCI
 /*
  * This function compares the known tables to find an iommu_table
  * that has already been built for hardware TCEs.
@@ -159,6 +159,7 @@ void iommu_devnode_init_iSeries(struct iSeries_Device_Node *dn)
         else
                 kfree(tbl);
 }
+#endif
 
 static void iommu_dev_setup_iSeries(struct pci_dev *dev) { }
 static void iommu_bus_setup_iSeries(struct pci_bus *bus) { }
diff --git a/arch/ppc64/kernel/iSeries_irq.c b/arch/ppc64/kernel/iSeries_irq.c
index f831d259dbb7..77376c1bd611 100644
--- a/arch/ppc64/kernel/iSeries_irq.c
+++ b/arch/ppc64/kernel/iSeries_irq.c
@@ -1,27 +1,29 @@
-/************************************************************************/
-/* This module supports the iSeries PCI bus interrupt handling          */
-/* Copyright (C) 20yy  <Robert L Holtorf> <IBM Corp>                    */
-/*                                                                      */
-/* This program is free software; you can redistribute it and/or modify */
-/* it under the terms of the GNU General Public License as published by */
-/* the Free Software Foundation; either version 2 of the License, or    */
-/* (at your option) any later version.                                  */
-/*                                                                      */
-/* This program is distributed in the hope that it will be useful,      */ 
-/* but WITHOUT ANY WARRANTY; without even the implied warranty of       */
-/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        */
-/* GNU General Public License for more details.                         */
-/*                                                                      */
-/* You should have received a copy of the GNU General Public License    */ 
-/* along with this program; if not, write to the:                       */
-/* Free Software Foundation, Inc.,                                      */ 
-/* 59 Temple Place, Suite 330,                                          */ 
-/* Boston, MA  02111-1307  USA                                          */
-/************************************************************************/
-/* Change Activity:                                                     */
-/*   Created, December 13, 2000 by Wayne Holm                           */ 
-/* End Change Activity                                                  */
-/************************************************************************/
+/*
+ * This module supports the iSeries PCI bus interrupt handling
+ * Copyright (C) 20yy  <Robert L Holtorf> <IBM Corp>
+ * Copyright (C) 2004-2005 IBM Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the:
+ * Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330,
+ * Boston, MA  02111-1307  USA
+ *
+ * Change Activity:
+ *   Created, December 13, 2000 by Wayne Holm
+ * End Change Activity
+ */
+#include <linux/config.h>
 #include <linux/pci.h>
 #include <linux/init.h>
 #include <linux/threads.h>
@@ -30,30 +32,15 @@
 #include <linux/string.h>
 #include <linux/bootmem.h>
 #include <linux/ide.h>
-
 #include <linux/irq.h>
 #include <linux/spinlock.h>
-#include <asm/ppcdebug.h>
 
+#include <asm/ppcdebug.h>
+#include <asm/iSeries/HvTypes.h>
+#include <asm/iSeries/HvLpEvent.h>
 #include <asm/iSeries/HvCallPci.h>
 #include <asm/iSeries/HvCallXm.h>
 #include <asm/iSeries/iSeries_irq.h>
-#include <asm/iSeries/XmPciLpEvent.h>
-
-static unsigned int iSeries_startup_IRQ(unsigned int irq);
-static void iSeries_shutdown_IRQ(unsigned int irq);
-static void iSeries_enable_IRQ(unsigned int irq);
-static void iSeries_disable_IRQ(unsigned int irq);
-static void iSeries_end_IRQ(unsigned int irq);
-
-static hw_irq_controller iSeries_IRQ_handler = {
-        .typename = "iSeries irq controller",
-        .startup = iSeries_startup_IRQ,
-        .shutdown = iSeries_shutdown_IRQ,
-        .enable = iSeries_enable_IRQ,
-        .disable = iSeries_disable_IRQ,
-        .end = iSeries_end_IRQ
-};
 
 /* This maps virtual irq numbers to real irqs */
 unsigned int virt_irq_to_real_map[NR_IRQS];
@@ -62,37 +49,187 @@ unsigned int virt_irq_to_real_map[NR_IRQS];
 /* Note: the pcnet32 driver assumes irq numbers < 2 aren't valid. :( */
 static int next_virtual_irq = 2;
 
-/* This is called by init_IRQ.  set in ppc_md.init_IRQ by iSeries_setup.c */
-void __init iSeries_init_IRQ(void)
+static long Pci_Interrupt_Count;
+static long Pci_Event_Count;
+
+enum XmPciLpEvent_Subtype {
+        XmPciLpEvent_BusCreated         = 0,    // PHB has been created
+        XmPciLpEvent_BusError           = 1,    // PHB has failed
+        XmPciLpEvent_BusFailed          = 2,    // Msg to Secondary, Primary failed bus
+        XmPciLpEvent_NodeFailed         = 4,    // Multi-adapter bridge has failed
+        XmPciLpEvent_NodeRecovered      = 5,    // Multi-adapter bridge has recovered
+        XmPciLpEvent_BusRecovered       = 12,   // PHB has been recovered
+        XmPciLpEvent_UnQuiesceBus       = 18,   // Secondary bus unqiescing
+        XmPciLpEvent_BridgeError        = 21,   // Bridge Error
+        XmPciLpEvent_SlotInterrupt      = 22    // Slot interrupt
+};
+
+struct XmPciLpEvent_BusInterrupt {
+        HvBusNumber     busNumber;
+        HvSubBusNumber  subBusNumber;
+};
+
+struct XmPciLpEvent_NodeInterrupt {
+        HvBusNumber     busNumber;
+        HvSubBusNumber  subBusNumber;
+        HvAgentId       deviceId;
+};
+
+struct XmPciLpEvent {
+        struct HvLpEvent hvLpEvent;
+
+        union {
+                u64 alignData;                  // Align on an 8-byte boundary
+
+                struct {
+                        u32             fisr;
+                        HvBusNumber     busNumber;
+                        HvSubBusNumber  subBusNumber;
+                        HvAgentId       deviceId;
+                } slotInterrupt;
+
+                struct XmPciLpEvent_BusInterrupt busFailed;
+                struct XmPciLpEvent_BusInterrupt busRecovered;
+                struct XmPciLpEvent_BusInterrupt busCreated;
+
+                struct XmPciLpEvent_NodeInterrupt nodeFailed;
+                struct XmPciLpEvent_NodeInterrupt nodeRecovered;
+
+        } eventData;
+
+};
+
+static void intReceived(struct XmPciLpEvent *eventParm,
+                struct pt_regs *regsParm)
 {
-        /* Register PCI event handler and open an event path */
-        XmPciLpEvent_init();
+        int irq;
+
+        ++Pci_Interrupt_Count;
+
+        switch (eventParm->hvLpEvent.xSubtype) {
+        case XmPciLpEvent_SlotInterrupt:
+                irq = eventParm->hvLpEvent.xCorrelationToken;
+                /* Dispatch the interrupt handlers for this irq */
+                ppc_irq_dispatch_handler(regsParm, irq);
+                HvCallPci_eoi(eventParm->eventData.slotInterrupt.busNumber,
+                        eventParm->eventData.slotInterrupt.subBusNumber,
+                        eventParm->eventData.slotInterrupt.deviceId);
+                break;
+                /* Ignore error recovery events for now */
+        case XmPciLpEvent_BusCreated:
+                printk(KERN_INFO "intReceived: system bus %d created\n",
+                        eventParm->eventData.busCreated.busNumber);
+                break;
+        case XmPciLpEvent_BusError:
+        case XmPciLpEvent_BusFailed:
+                printk(KERN_INFO "intReceived: system bus %d failed\n",
+                        eventParm->eventData.busFailed.busNumber);
+                break;
+        case XmPciLpEvent_BusRecovered:
+        case XmPciLpEvent_UnQuiesceBus:
+                printk(KERN_INFO "intReceived: system bus %d recovered\n",
+                        eventParm->eventData.busRecovered.busNumber);
+                break;
+        case XmPciLpEvent_NodeFailed:
+        case XmPciLpEvent_BridgeError:
+                printk(KERN_INFO
+                        "intReceived: multi-adapter bridge %d/%d/%d failed\n",
+                        eventParm->eventData.nodeFailed.busNumber,
+                        eventParm->eventData.nodeFailed.subBusNumber,
+                        eventParm->eventData.nodeFailed.deviceId);
+                break;
+        case XmPciLpEvent_NodeRecovered:
+                printk(KERN_INFO
+                        "intReceived: multi-adapter bridge %d/%d/%d recovered\n",
+                        eventParm->eventData.nodeRecovered.busNumber,
+                        eventParm->eventData.nodeRecovered.subBusNumber,
+                        eventParm->eventData.nodeRecovered.deviceId);
+                break;
+        default:
+                printk(KERN_ERR
+                        "intReceived: unrecognized event subtype 0x%x\n",
+                        eventParm->hvLpEvent.xSubtype);
+                break;
+        }
+}
+
+static void XmPciLpEvent_handler(struct HvLpEvent *eventParm,
+                struct pt_regs *regsParm)
+{
+#ifdef CONFIG_PCI
+        ++Pci_Event_Count;
+
+        if (eventParm && (eventParm->xType == HvLpEvent_Type_PciIo)) {
+                switch (eventParm->xFlags.xFunction) {
+                case HvLpEvent_Function_Int:
+                        intReceived((struct XmPciLpEvent *)eventParm, regsParm);
+                        break;
+                case HvLpEvent_Function_Ack:
+                        printk(KERN_ERR
+                                "XmPciLpEvent_handler: unexpected ack received\n");
+                        break;
+                default:
+                        printk(KERN_ERR
+                                "XmPciLpEvent_handler: unexpected event function %d\n",
+                                (int)eventParm->xFlags.xFunction);
+                        break;
+                }
+        } else if (eventParm)
+                printk(KERN_ERR
+                        "XmPciLpEvent_handler: Unrecognized PCI event type 0x%x\n",
+                        (int)eventParm->xType);
+        else
+                printk(KERN_ERR "XmPciLpEvent_handler: NULL event received\n");
+#endif
 }
 
 /*
- * This is called out of iSeries_scan_slot to allocate an IRQ for an EADS slot
- * It calculates the irq value for the slot.
- * Note that subBusNumber is always 0 (at the moment at least).
+ * This is called by init_IRQ.  set in ppc_md.init_IRQ by iSeries_setup.c
+ * It must be called before the bus walk.
  */
-int __init iSeries_allocate_IRQ(HvBusNumber busNumber,
-                HvSubBusNumber subBusNumber, HvAgentId deviceId)
+void __init iSeries_init_IRQ(void)
 {
-        unsigned int realirq, virtirq;
-        u8 idsel = (deviceId >> 4);
-        u8 function = deviceId & 7;
-
-        virtirq = next_virtual_irq++;
-        realirq = ((busNumber - 1) << 6) + ((idsel - 1) << 3) + function;
-        virt_irq_to_real_map[virtirq] = realirq;
+        /* Register PCI event handler and open an event path */
+        int xRc;
 
-        irq_desc[virtirq].handler = &iSeries_IRQ_handler;
-        return virtirq;
+        xRc = HvLpEvent_registerHandler(HvLpEvent_Type_PciIo,
+                        &XmPciLpEvent_handler);
+        if (xRc == 0) {
+                xRc = HvLpEvent_openPath(HvLpEvent_Type_PciIo, 0);
+                if (xRc != 0)
+                        printk(KERN_ERR "iSeries_init_IRQ: open event path "
+                                        "failed with rc 0x%x\n", xRc);
+        } else
+                printk(KERN_ERR "iSeries_init_IRQ: register handler "
+                                "failed with rc 0x%x\n", xRc);
 }
 
 #define REAL_IRQ_TO_BUS(irq)    ((((irq) >> 6) & 0xff) + 1)
 #define REAL_IRQ_TO_IDSEL(irq)  ((((irq) >> 3) & 7) + 1)
 #define REAL_IRQ_TO_FUNC(irq)   ((irq) & 7)
 
+/*
+ * This will be called by device drivers (via enable_IRQ)
+ * to enable INTA in the bridge interrupt status register.
+ */
+static void iSeries_enable_IRQ(unsigned int irq)
+{
+        u32 bus, deviceId, function, mask;
+        const u32 subBus = 0;
+        unsigned int rirq = virt_irq_to_real_map[irq];
+
+        /* The IRQ has already been locked by the caller */
+        bus = REAL_IRQ_TO_BUS(rirq);
+        function = REAL_IRQ_TO_FUNC(rirq);
+        deviceId = (REAL_IRQ_TO_IDSEL(rirq) << 4) + function;
+
+        /* Unmask secondary INTA */
+        mask = 0x80000000;
+        HvCallPci_unmaskInterrupts(bus, subBus, deviceId, mask);
+        PPCDBG(PPCDBG_BUSWALK, "iSeries_enable_IRQ 0x%02X.%02X.%02X 0x%04X\n",
+                        bus, subBus, deviceId, irq);
+}
+
 /* This is called by iSeries_activate_IRQs */
 static unsigned int iSeries_startup_IRQ(unsigned int irq)
 {
@@ -131,7 +268,7 @@ void __init iSeries_activate_IRQs()
                         desc->handler->startup(irq);
                         spin_unlock_irqrestore(&desc->lock, flags);
                 }
-        }
+        }
 }
 
 /*  this is not called anywhere currently */
@@ -173,29 +310,7 @@ static void iSeries_disable_IRQ(unsigned int irq)
         mask = 0x80000000;
         HvCallPci_maskInterrupts(bus, subBus, deviceId, mask);
         PPCDBG(PPCDBG_BUSWALK, "iSeries_disable_IRQ 0x%02X.%02X.%02X 0x%04X\n",
-               bus, subBus, deviceId, irq);
-}
-
-/*
- * This will be called by device drivers (via enable_IRQ)
- * to enable INTA in the bridge interrupt status register.
- */
-static void iSeries_enable_IRQ(unsigned int irq)
-{
-        u32 bus, deviceId, function, mask;
-        const u32 subBus = 0;
-        unsigned int rirq = virt_irq_to_real_map[irq];
-
-        /* The IRQ has already been locked by the caller */
-        bus = REAL_IRQ_TO_BUS(rirq);
-        function = REAL_IRQ_TO_FUNC(rirq);
-        deviceId = (REAL_IRQ_TO_IDSEL(rirq) << 4) + function;
-
-        /* Unmask secondary INTA */
-        mask = 0x80000000;
-        HvCallPci_unmaskInterrupts(bus, subBus, deviceId, mask);
-        PPCDBG(PPCDBG_BUSWALK, "iSeries_enable_IRQ 0x%02X.%02X.%02X 0x%04X\n",
-               bus, subBus, deviceId, irq);
+                        bus, subBus, deviceId, irq);
 }
 
 /*
@@ -207,3 +322,32 @@ static void iSeries_enable_IRQ(unsigned int irq)
 static void iSeries_end_IRQ(unsigned int irq)
 {
 }
+
+static hw_irq_controller iSeries_IRQ_handler = {
+        .typename = "iSeries irq controller",
+        .startup = iSeries_startup_IRQ,
+        .shutdown = iSeries_shutdown_IRQ,
+        .enable = iSeries_enable_IRQ,
+        .disable = iSeries_disable_IRQ,
+        .end = iSeries_end_IRQ
+};
+
+/*
+ * This is called out of iSeries_scan_slot to allocate an IRQ for an EADS slot
+ * It calculates the irq value for the slot.
+ * Note that subBusNumber is always 0 (at the moment at least).
+ */
+int __init iSeries_allocate_IRQ(HvBusNumber busNumber,
+                HvSubBusNumber subBusNumber, HvAgentId deviceId)
+{
+        unsigned int realirq, virtirq;
+        u8 idsel = (deviceId >> 4);
+        u8 function = deviceId & 7;
+
+        virtirq = next_virtual_irq++;
+        realirq = ((busNumber - 1) << 6) + ((idsel - 1) << 3) + function;
+        virt_irq_to_real_map[virtirq] = realirq;
+
+        irq_desc[virtirq].handler = &iSeries_IRQ_handler;
+        return virtirq;
+}
diff --git a/arch/ppc64/kernel/iSeries_pci.c b/arch/ppc64/kernel/iSeries_pci.c
index bd4c2554f1a0..356e4fd9a94f 100644
--- a/arch/ppc64/kernel/iSeries_pci.c
+++ b/arch/ppc64/kernel/iSeries_pci.c
@@ -38,9 +38,7 @@
 #include <asm/iommu.h>
 
 #include <asm/iSeries/HvCallPci.h>
-#include <asm/iSeries/HvCallSm.h>
 #include <asm/iSeries/HvCallXm.h>
-#include <asm/iSeries/LparData.h>
 #include <asm/iSeries/iSeries_irq.h>
 #include <asm/iSeries/iSeries_pci.h>
 #include <asm/iSeries/mf.h>
@@ -225,10 +223,7 @@ static struct iSeries_Device_Node *build_device_node(HvBusNumber Bus,
         node->DsaAddr.Dsa.busNumber = Bus;
         node->DsaAddr.Dsa.subBusNumber = SubBus;
         node->DsaAddr.Dsa.deviceId = 0x10;
-        node->AgentId = AgentId;
         node->DevFn = PCI_DEVFN(ISERIES_ENCODE_DEVICE(AgentId), Function);
-        node->IoRetry = 0;
-        iSeries_Get_Location_Code(node);
         return node;
 }
 
@@ -302,7 +297,6 @@ void __init iSeries_pci_final_fixup(void)
 {
         struct pci_dev *pdev = NULL;
         struct iSeries_Device_Node *node;
-        char Buffer[256];
         int DeviceCount = 0;
 
         PPCDBG(PPCDBG_BUSWALK, "iSeries_pcibios_fixup Entry.\n"); 
@@ -324,9 +318,7 @@ void __init iSeries_pci_final_fixup(void)
                                         "pdev 0x%p <==> DevNode 0x%p\n",
                                         pdev, node);
                         allocate_device_bars(pdev);
-                        iSeries_Device_Information(pdev, Buffer,
-                                        sizeof(Buffer));
-                        printk("%d. %s\n", DeviceCount, Buffer);
+                        iSeries_Device_Information(pdev, DeviceCount);
                         iommu_devnode_init_iSeries(node);
                 } else
                         printk("PCI: Device Tree not found for 0x%016lX\n",
@@ -499,7 +491,6 @@ static int scan_bridge_slot(HvBusNumber Bus,
 
                         ++DeviceCount;
                         node = build_device_node(Bus, SubBus, EADsIdSel, Function);
-                        node->Vendor = VendorId;
                         node->Irq = Irq;
                         node->LogicalSlot = BridgeInfo->logicalSlotNumber;
 
@@ -661,38 +652,34 @@ static struct pci_ops iSeries_pci_ops = {
  * Check Return Code
  * -> On Failure, print and log information.
  *    Increment Retry Count, if exceeds max, panic partition.
- * -> If in retry, print and log success 
  *
  * PCI: Device 23.90 ReadL I/O Error( 0): 0x1234
  * PCI: Device 23.90 ReadL Retry( 1)
  * PCI: Device 23.90 ReadL Retry Successful(1)
  */
 static int CheckReturnCode(char *TextHdr, struct iSeries_Device_Node *DevNode,
-                u64 ret)
+                int *retry, u64 ret)
 {
         if (ret != 0)  {
                 ++Pci_Error_Count;
-                ++DevNode->IoRetry;
+                (*retry)++;
                 printk("PCI: %s: Device 0x%04X:%02X  I/O Error(%2d): 0x%04X\n",
                                 TextHdr, DevNode->DsaAddr.Dsa.busNumber, DevNode->DevFn,
-                                DevNode->IoRetry, (int)ret);
+                                *retry, (int)ret);
                 /*
                  * Bump the retry and check for retry count exceeded.
                  * If, Exceeded, panic the system.
                  */
-                if ((DevNode->IoRetry > Pci_Retry_Max) &&
+                if (((*retry) > Pci_Retry_Max) &&
                                 (Pci_Error_Flag > 0)) {
                         mf_display_src(0xB6000103);
-                        panic_timeout = 0; 
+                        panic_timeout = 0;
                         panic("PCI: Hardware I/O Error, SRC B6000103, "
                                         "Automatic Reboot Disabled.\n");
                 }
                 return -1;      /* Retry Try */
         }
-        /* If retry was in progress, log success and rest retry count */
-        if (DevNode->IoRetry > 0)
-                DevNode->IoRetry = 0;
-        return 0; 
+        return 0;
 }
 
 /*
@@ -738,6 +725,7 @@ u8 iSeries_Read_Byte(const volatile void __iomem *IoAddress)
 {
         u64 BarOffset;
         u64 dsa;
+        int retry = 0;
         struct HvCallPci_LoadReturn ret;
         struct iSeries_Device_Node *DevNode =
                 xlate_iomm_address(IoAddress, &dsa, &BarOffset);
@@ -757,7 +745,7 @@ u8 iSeries_Read_Byte(const volatile void __iomem *IoAddress)
         do {
                 ++Pci_Io_Read_Count;
                 HvCall3Ret16(HvCallPciBarLoad8, &ret, dsa, BarOffset, 0);
-        } while (CheckReturnCode("RDB", DevNode, ret.rc) != 0);
+        } while (CheckReturnCode("RDB", DevNode, &retry, ret.rc) != 0);
 
         return (u8)ret.value;
 }
@@ -767,6 +755,7 @@ u16 iSeries_Read_Word(const volatile void __iomem *IoAddress)
 {
         u64 BarOffset;
         u64 dsa;
+        int retry = 0;
         struct HvCallPci_LoadReturn ret;
         struct iSeries_Device_Node *DevNode =
                 xlate_iomm_address(IoAddress, &dsa, &BarOffset);
@@ -787,7 +776,7 @@ u16 iSeries_Read_Word(const volatile void __iomem *IoAddress)
                 ++Pci_Io_Read_Count;
                 HvCall3Ret16(HvCallPciBarLoad16, &ret, dsa,
                                 BarOffset, 0);
-        } while (CheckReturnCode("RDW", DevNode, ret.rc) != 0);
+        } while (CheckReturnCode("RDW", DevNode, &retry, ret.rc) != 0);
 
         return swab16((u16)ret.value);
 }
@@ -797,6 +786,7 @@ u32 iSeries_Read_Long(const volatile void __iomem *IoAddress)
 {
         u64 BarOffset;
         u64 dsa;
+        int retry = 0;
         struct HvCallPci_LoadReturn ret;
         struct iSeries_Device_Node *DevNode =
                 xlate_iomm_address(IoAddress, &dsa, &BarOffset);
@@ -817,7 +807,7 @@ u32 iSeries_Read_Long(const volatile void __iomem *IoAddress)
                 ++Pci_Io_Read_Count;
                 HvCall3Ret16(HvCallPciBarLoad32, &ret, dsa,
                                 BarOffset, 0);
-        } while (CheckReturnCode("RDL", DevNode, ret.rc) != 0);
+        } while (CheckReturnCode("RDL", DevNode, &retry, ret.rc) != 0);
 
         return swab32((u32)ret.value);
 }
@@ -834,6 +824,7 @@ void iSeries_Write_Byte(u8 data, volatile void __iomem *IoAddress)
 {
         u64 BarOffset;
         u64 dsa;
+        int retry = 0;
         u64 rc;
         struct iSeries_Device_Node *DevNode =
                 xlate_iomm_address(IoAddress, &dsa, &BarOffset);
@@ -853,7 +844,7 @@ void iSeries_Write_Byte(u8 data, volatile void __iomem *IoAddress)
         do {
                 ++Pci_Io_Write_Count;
                 rc = HvCall4(HvCallPciBarStore8, dsa, BarOffset, data, 0);
-        } while (CheckReturnCode("WWB", DevNode, rc) != 0);
+        } while (CheckReturnCode("WWB", DevNode, &retry, rc) != 0);
 }
 EXPORT_SYMBOL(iSeries_Write_Byte);
 
@@ -861,6 +852,7 @@ void iSeries_Write_Word(u16 data, volatile void __iomem *IoAddress)
 {
         u64 BarOffset;
         u64 dsa;
+        int retry = 0;
         u64 rc;
         struct iSeries_Device_Node *DevNode =
                 xlate_iomm_address(IoAddress, &dsa, &BarOffset);
@@ -880,7 +872,7 @@ void iSeries_Write_Word(u16 data, volatile void __iomem *IoAddress)
         do {
                 ++Pci_Io_Write_Count;
                 rc = HvCall4(HvCallPciBarStore16, dsa, BarOffset, swab16(data), 0);
-        } while (CheckReturnCode("WWW", DevNode, rc) != 0);
+        } while (CheckReturnCode("WWW", DevNode, &retry, rc) != 0);
 }
 EXPORT_SYMBOL(iSeries_Write_Word);
 
@@ -888,6 +880,7 @@ void iSeries_Write_Long(u32 data, volatile void __iomem *IoAddress)
 {
         u64 BarOffset;
         u64 dsa;
+        int retry = 0;
         u64 rc;
         struct iSeries_Device_Node *DevNode =
                 xlate_iomm_address(IoAddress, &dsa, &BarOffset);
@@ -907,6 +900,6 @@ void iSeries_Write_Long(u32 data, volatile void __iomem *IoAddress)
         do {
                 ++Pci_Io_Write_Count;
                 rc = HvCall4(HvCallPciBarStore32, dsa, BarOffset, swab32(data), 0);
-        } while (CheckReturnCode("WWL", DevNode, rc) != 0);
+        } while (CheckReturnCode("WWL", DevNode, &retry, rc) != 0);
 }
 EXPORT_SYMBOL(iSeries_Write_Long);
diff --git a/arch/ppc64/kernel/iSeries_pci_reset.c b/arch/ppc64/kernel/iSeries_pci_reset.c
deleted file mode 100644
index 0f785e4584f7..000000000000
--- a/arch/ppc64/kernel/iSeries_pci_reset.c
+++ /dev/null
@@ -1,104 +0,0 @@
-#define PCIFR(...)
-/************************************************************************/
-/* File iSeries_pci_reset.c created by Allan Trautman on Mar 21 2001.   */
-/************************************************************************/
-/* This code supports the pci interface on the IBM iSeries systems.     */
-/* Copyright (C) 20yy  <Allan H Trautman> <IBM Corp>                    */
-/*                                                                      */
-/* This program is free software; you can redistribute it and/or modify */
-/* it under the terms of the GNU General Public License as published by */
-/* the Free Software Foundation; either version 2 of the License, or    */
-/* (at your option) any later version.                                  */
-/*                                                                      */
-/* This program is distributed in the hope that it will be useful,      */ 
-/* but WITHOUT ANY WARRANTY; without even the implied warranty of       */
-/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        */
-/* GNU General Public License for more details.                         */
-/*                                                                      */
-/* You should have received a copy of the GNU General Public License    */ 
-/* along with this program; if not, write to the:                       */
-/* Free Software Foundation, Inc.,                                      */ 
-/* 59 Temple Place, Suite 330,                                          */ 
-/* Boston, MA  02111-1307  USA                                          */
-/************************************************************************/
-/* Change Activity:                                                     */
-/*   Created, March 20, 2001                                            */
-/*   April 30, 2001, Added return codes on functions.                   */
-/*   September 10, 2001, Ported to ppc64.                               */
-/* End Change Activity                                                  */
-/************************************************************************/
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/pci.h>
-#include <linux/irq.h>
-#include <linux/delay.h>
-
-#include <asm/io.h>
-#include <asm/iSeries/HvCallPci.h>
-#include <asm/iSeries/HvTypes.h>
-#include <asm/iSeries/mf.h>
-#include <asm/pci.h>
-
-#include <asm/iSeries/iSeries_pci.h>
-#include "pci.h"
-
-/*
- * Interface to toggle the reset line
- * Time is in .1 seconds, need for seconds.
- */
-int iSeries_Device_ToggleReset(struct pci_dev *PciDev, int AssertTime,
-                int DelayTime)
-{
-        unsigned int AssertDelay, WaitDelay;
-        struct iSeries_Device_Node *DeviceNode =
-                (struct iSeries_Device_Node *)PciDev->sysdata;
-
-        if (DeviceNode == NULL) { 
-                printk("PCI: Pci Reset Failed, Device Node not found for pci_dev %p\n",
-                                PciDev);
-                return -1;
-        }
-        /*
-         * Set defaults, Assert is .5 second, Wait is 3 seconds.
-         */
-        if (AssertTime == 0)
-                AssertDelay = 500;
-        else
-                AssertDelay = AssertTime * 100;
-
-        if (DelayTime == 0)
-                WaitDelay = 3000;
-        else
-                WaitDelay = DelayTime * 100;
-
-        /*
-         * Assert reset
-         */
-        DeviceNode->ReturnCode = HvCallPci_setSlotReset(ISERIES_BUS(DeviceNode),
-                        0x00, DeviceNode->AgentId, 1);
-        if (DeviceNode->ReturnCode == 0) {
-                msleep(AssertDelay);                    /* Sleep for the time */
-                DeviceNode->ReturnCode =
-                        HvCallPci_setSlotReset(ISERIES_BUS(DeviceNode),
-                                        0x00, DeviceNode->AgentId, 0);
-
-                /*
-                 * Wait for device to reset
-                 */
-                msleep(WaitDelay);
-        }
-        if (DeviceNode->ReturnCode == 0)
-                PCIFR("Slot 0x%04X.%02 Reset\n", ISERIES_BUS(DeviceNode),
-                                DeviceNode->AgentId);
-        else {
-                printk("PCI: Slot 0x%04X.%02X Reset Failed, RCode: %04X\n",
-                                ISERIES_BUS(DeviceNode), DeviceNode->AgentId,
-                                DeviceNode->ReturnCode);
-                PCIFR("Slot 0x%04X.%02X Reset Failed, RCode: %04X\n",
-                                ISERIES_BUS(DeviceNode), DeviceNode->AgentId,
-                                DeviceNode->ReturnCode);
-        }
-        return DeviceNode->ReturnCode;
-}
-EXPORT_SYMBOL(iSeries_Device_ToggleReset);
diff --git a/arch/ppc64/kernel/iSeries_proc.c b/arch/ppc64/kernel/iSeries_proc.c
index 0cc58ddf48de..0fe3116eba29 100644
--- a/arch/ppc64/kernel/iSeries_proc.c
+++ b/arch/ppc64/kernel/iSeries_proc.c
@@ -28,8 +28,7 @@
 #include <asm/iSeries/ItLpQueue.h>
 #include <asm/iSeries/HvCallXm.h>
 #include <asm/iSeries/IoHriMainStore.h>
-#include <asm/iSeries/LparData.h>
-#include <asm/iSeries/iSeries_proc.h>
+#include <asm/iSeries/IoHriProcessorVpd.h>
 
 static int __init iseries_proc_create(void)
 {
@@ -41,50 +40,6 @@ static int __init iseries_proc_create(void)
 }
 core_initcall(iseries_proc_create);
 
-static char *event_types[9] = {
-        "Hypervisor\t\t",
-        "Machine Facilities\t",
-        "Session Manager\t",
-        "SPD I/O\t\t",
-        "Virtual Bus\t\t",
-        "PCI I/O\t\t",
-        "RIO I/O\t\t",
-        "Virtual Lan\t\t",
-        "Virtual I/O\t\t"
-};
-
-static int proc_lpevents_show(struct seq_file *m, void *v)
-{
-        unsigned int i;
-
-        seq_printf(m, "LpEventQueue 0\n");
-        seq_printf(m, "  events processed:\t%lu\n",
-                   (unsigned long)xItLpQueue.xLpIntCount);
-
-        for (i = 0; i < 9; ++i)
-                seq_printf(m, "    %s %10lu\n", event_types[i],
-                           (unsigned long)xItLpQueue.xLpIntCountByType[i]);
-
-        seq_printf(m, "\n  events processed by processor:\n");
-
-        for_each_online_cpu(i)
-                seq_printf(m, "    CPU%02d  %10u\n", i, paca[i].lpevent_count);
-
-        return 0;
-}
-
-static int proc_lpevents_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, proc_lpevents_show, NULL);
-}
-
-static struct file_operations proc_lpevents_operations = {
-        .open           = proc_lpevents_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
-};
-
 static unsigned long startTitan = 0;
 static unsigned long startTb = 0;
 
@@ -149,10 +104,6 @@ static int __init iseries_proc_init(void)
 {
         struct proc_dir_entry *e;
 
-        e = create_proc_entry("iSeries/lpevents", S_IFREG|S_IRUGO, NULL);
-        if (e)
-                e->proc_fops = &proc_lpevents_operations;
-
         e = create_proc_entry("iSeries/titanTod", S_IFREG|S_IRUGO, NULL);
         if (e)
                 e->proc_fops = &proc_titantod_operations;
diff --git a/arch/ppc64/kernel/iSeries_setup.c b/arch/ppc64/kernel/iSeries_setup.c
index 6d06eb550a3f..b3f770f6d402 100644
--- a/arch/ppc64/kernel/iSeries_setup.c
+++ b/arch/ppc64/kernel/iSeries_setup.c
@@ -24,7 +24,6 @@
 #include <linux/smp.h>
 #include <linux/param.h>
 #include <linux/string.h>
-#include <linux/bootmem.h>
 #include <linux/initrd.h>
 #include <linux/seq_file.h>
 #include <linux/kdev_t.h>
@@ -47,7 +46,7 @@
 #include <asm/paca.h>
 #include <asm/cache.h>
 #include <asm/sections.h>
-#include <asm/iSeries/LparData.h>
+#include <asm/abs_addr.h>
 #include <asm/iSeries/HvCallHpt.h>
 #include <asm/iSeries/HvLpConfig.h>
 #include <asm/iSeries/HvCallEvent.h>
@@ -55,10 +54,12 @@
 #include <asm/iSeries/HvCallXm.h>
 #include <asm/iSeries/ItLpQueue.h>
 #include <asm/iSeries/IoHriMainStore.h>
-#include <asm/iSeries/iSeries_proc.h>
 #include <asm/iSeries/mf.h>
 #include <asm/iSeries/HvLpEvent.h>
 #include <asm/iSeries/iSeries_irq.h>
+#include <asm/iSeries/IoHriProcessorVpd.h>
+#include <asm/iSeries/ItVpdAreas.h>
+#include <asm/iSeries/LparMap.h>
 
 extern void hvlog(char *fmt, ...);
 
@@ -74,7 +75,11 @@ extern void ppcdbg_initialize(void);
 static void build_iSeries_Memory_Map(void);
 static void setup_iSeries_cache_sizes(void);
 static void iSeries_bolt_kernel(unsigned long saddr, unsigned long eaddr);
+#ifdef CONFIG_PCI
 extern void iSeries_pci_final_fixup(void);
+#else
+static void iSeries_pci_final_fixup(void) { }
+#endif
 
 /* Global Variables */
 static unsigned long procFreqHz;
@@ -665,15 +670,11 @@ static void __init iSeries_bolt_kernel(unsigned long saddr, unsigned long eaddr)
         }
 }
 
-extern unsigned long ppc_proc_freq;
-extern unsigned long ppc_tb_freq;
-
 /*
  * Document me.
  */
 static void __init iSeries_setup_arch(void)
 {
-        void *eventStack;
         unsigned procIx = get_paca()->lppaca.dyn_hv_phys_proc_index;
 
         /* Add an eye catcher and the systemcfg layout version number */
@@ -682,24 +683,7 @@ static void __init iSeries_setup_arch(void)
         systemcfg->version.minor = SYSTEMCFG_MINOR;
 
         /* Setup the Lp Event Queue */
-
-        /* Allocate a page for the Event Stack
-         * The hypervisor wants the absolute real address, so
-         * we subtract out the KERNELBASE and add in the
-         * absolute real address of the kernel load area
-         */
-        eventStack = alloc_bootmem_pages(LpEventStackSize);
-        memset(eventStack, 0, LpEventStackSize);
-
-        /* Invoke the hypervisor to initialize the event stack */
-        HvCallEvent_setLpEventStack(0, eventStack, LpEventStackSize);
-
-        /* Initialize fields in our Lp Event Queue */
-        xItLpQueue.xSlicEventStackPtr = (char *)eventStack;
-        xItLpQueue.xSlicCurEventPtr = (char *)eventStack;
-        xItLpQueue.xSlicLastValidEventPtr = (char *)eventStack +
-                                        (LpEventStackSize - LpEventMaxSize);
-        xItLpQueue.xIndex = 0;
+        setup_hvlpevent_queue();
 
         /* Compute processor frequency */
         procFreqHz = ((1UL << 34) * 1000000) /
@@ -766,8 +750,6 @@ static void iSeries_halt(void)
         mf_power_off();
 }
 
-extern void setup_default_decr(void);
-
 /*
  * void __init iSeries_calibrate_decr()
  *
@@ -852,27 +834,9 @@ static int __init iSeries_src_init(void)
 
 late_initcall(iSeries_src_init);
 
-static int set_spread_lpevents(char *str)
-{
-        unsigned long i;
-        unsigned long val = simple_strtoul(str, NULL, 0);
-
-        /*
-         * The parameter is the number of processors to share in processing
-         * lp events.
-         */
-        if (( val > 0) && (val <= NR_CPUS)) {
-                for (i = 1; i < val; ++i)
-                        paca[i].lpqueue_ptr = paca[0].lpqueue_ptr;
-
-                printk("lpevent processing spread over %ld processors\n", val);
-        } else {
-                printk("invalid spread_lpevents %ld\n", val);
-        }
-
-        return 1;
-}
-__setup("spread_lpevents=", set_spread_lpevents);
+#ifndef CONFIG_PCI
+void __init iSeries_init_IRQ(void) { }
+#endif
 
 void __init iSeries_early_setup(void)
 {
diff --git a/arch/ppc64/kernel/iSeries_smp.c b/arch/ppc64/kernel/iSeries_smp.c
index ba1f084d5462..f74386e31638 100644
--- a/arch/ppc64/kernel/iSeries_smp.c
+++ b/arch/ppc64/kernel/iSeries_smp.c
@@ -38,9 +38,7 @@
 #include <asm/io.h>
 #include <asm/smp.h>
 #include <asm/paca.h>
-#include <asm/iSeries/LparData.h>
 #include <asm/iSeries/HvCall.h>
-#include <asm/iSeries/HvCallCfg.h>
 #include <asm/time.h>
 #include <asm/ppcdebug.h>
 #include <asm/machdep.h>
diff --git a/arch/ppc64/kernel/idle.c b/arch/ppc64/kernel/idle.c
index f24ce2b87200..08952c7e6216 100644
--- a/arch/ppc64/kernel/idle.c
+++ b/arch/ppc64/kernel/idle.c
@@ -42,6 +42,11 @@ static int (*idle_loop)(void);
 static unsigned long maxYieldTime = 0;
 static unsigned long minYieldTime = 0xffffffffffffffffUL;
 
+static inline void process_iSeries_events(void)
+{
+        asm volatile ("li 0,0x5555; sc" : : : "r0", "r3");
+}
+
 static void yield_shared_processor(void)
 {
         unsigned long tb;
@@ -83,7 +88,7 @@ static int iSeries_idle(void)
 
         while (1) {
                 if (lpaca->lppaca.shared_proc) {
-                        if (ItLpQueue_isLpIntPending(lpaca->lpqueue_ptr))
+                        if (hvlpevent_is_pending())
                                 process_iSeries_events();
                         if (!need_resched())
                                 yield_shared_processor();
@@ -95,7 +100,7 @@ static int iSeries_idle(void)
 
                                 while (!need_resched()) {
                                         HMT_medium();
-                                        if (ItLpQueue_isLpIntPending(lpaca->lpqueue_ptr))
+                                        if (hvlpevent_is_pending())
                                                 process_iSeries_events();
                                         HMT_low();
                                 }
@@ -292,7 +297,7 @@ static int native_idle(void)
                 if (need_resched())
                         schedule();
 
-                if (cpu_is_offline(_smp_processor_id()) &&
+                if (cpu_is_offline(raw_smp_processor_id()) &&
                     system_state == SYSTEM_RUNNING)
                         cpu_die();
         }
diff --git a/arch/ppc64/kernel/iommu.c b/arch/ppc64/kernel/iommu.c
index 344164681d2c..8316426ccaf6 100644
--- a/arch/ppc64/kernel/iommu.c
+++ b/arch/ppc64/kernel/iommu.c
@@ -423,6 +423,9 @@ struct iommu_table *iommu_init_table(struct iommu_table *tbl)
         tbl->it_largehint = tbl->it_halfpoint;
         spin_lock_init(&tbl->it_lock);
 
+        /* Clear the hardware table in case firmware left allocations in it */
+        ppc_md.tce_free(tbl, tbl->it_offset, tbl->it_size);
+
         if (!welcomed) {
                 printk(KERN_INFO "IOMMU table initialized, virtual merging %s\n",
                        novmerge ? "disabled" : "enabled");
diff --git a/arch/ppc64/kernel/irq.c b/arch/ppc64/kernel/irq.c
index 4fd7f203c1e3..f41afe545045 100644
--- a/arch/ppc64/kernel/irq.c
+++ b/arch/ppc64/kernel/irq.c
@@ -52,7 +52,7 @@
 #include <asm/cache.h>
 #include <asm/prom.h>
 #include <asm/ptrace.h>
-#include <asm/iSeries/LparData.h>
+#include <asm/iSeries/ItLpQueue.h>
 #include <asm/machdep.h>
 #include <asm/paca.h>
 
@@ -66,7 +66,6 @@ EXPORT_SYMBOL(irq_desc);
 int distribute_irqs = 1;
 int __irq_offset_value;
 int ppc_spurious_interrupts;
-unsigned long lpevent_count;
 u64 ppc64_interrupt_controller;
 
 int show_interrupts(struct seq_file *p, void *v)
@@ -245,7 +244,7 @@ void ppc_irq_dispatch_handler(struct pt_regs *regs, int irq)
 
                 spin_lock(&desc->lock);
                 if (!noirqdebug)
-                        note_interrupt(irq, desc, action_ret);
+                        note_interrupt(irq, desc, action_ret, regs);
                 if (likely(!(desc->status & IRQ_PENDING)))
                         break;
                 desc->status &= ~IRQ_PENDING;
@@ -269,7 +268,6 @@ out:
 void do_IRQ(struct pt_regs *regs)
 {
         struct paca_struct *lpaca;
-        struct ItLpQueue *lpq;
 
         irq_enter();
 
@@ -295,9 +293,8 @@ void do_IRQ(struct pt_regs *regs)
                 iSeries_smp_message_recv(regs);
         }
 #endif /* CONFIG_SMP */
-        lpq = lpaca->lpqueue_ptr;
-        if (lpq && ItLpQueue_isLpIntPending(lpq))
-                lpevent_count += ItLpQueue_process(lpq, regs);
+        if (hvlpevent_is_pending())
+                process_hvlpevents(regs);
 
         irq_exit();
 
@@ -395,6 +392,9 @@ int virt_irq_create_mapping(unsigned int real_irq)
         if (ppc64_interrupt_controller == IC_OPEN_PIC)
                 return real_irq;        /* no mapping for openpic (for now) */
 
+        if (ppc64_interrupt_controller == IC_BPA_IIC)
+                return real_irq;        /* no mapping for iic either */
+
         /* don't map interrupts < MIN_VIRT_IRQ */
         if (real_irq < MIN_VIRT_IRQ) {
                 virt_irq_to_real_map[real_irq] = real_irq;
diff --git a/arch/ppc64/kernel/kprobes.c b/arch/ppc64/kernel/kprobes.c
index e950a2058a19..1d2ff6d6b0b3 100644
--- a/arch/ppc64/kernel/kprobes.c
+++ b/arch/ppc64/kernel/kprobes.c
@@ -32,15 +32,16 @@
 #include <linux/ptrace.h>
 #include <linux/spinlock.h>
 #include <linux/preempt.h>
+#include <asm/cacheflush.h>
 #include <asm/kdebug.h>
 #include <asm/sstep.h>
 
-/* kprobe_status settings */
-#define KPROBE_HIT_ACTIVE       0x00000001
-#define KPROBE_HIT_SS           0x00000002
+static DECLARE_MUTEX(kprobe_mutex);
 
 static struct kprobe *current_kprobe;
 static unsigned long kprobe_status, kprobe_saved_msr;
+static struct kprobe *kprobe_prev;
+static unsigned long kprobe_status_prev, kprobe_saved_msr_prev;
 static struct pt_regs jprobe_saved_regs;
 
 int arch_prepare_kprobe(struct kprobe *p)
@@ -55,32 +56,87 @@ int arch_prepare_kprobe(struct kprobe *p)
                 printk("Cannot register a kprobe on rfid or mtmsrd\n");
                 ret = -EINVAL;
         }
+
+        /* insn must be on a special executable page on ppc64 */
+        if (!ret) {
+                up(&kprobe_mutex);
+                p->ainsn.insn = get_insn_slot();
+                down(&kprobe_mutex);
+                if (!p->ainsn.insn)
+                        ret = -ENOMEM;
+        }
         return ret;
 }
 
 void arch_copy_kprobe(struct kprobe *p)
 {
         memcpy(p->ainsn.insn, p->addr, MAX_INSN_SIZE * sizeof(kprobe_opcode_t));
+        p->opcode = *p->addr;
 }
 
-void arch_remove_kprobe(struct kprobe *p)
+void arch_arm_kprobe(struct kprobe *p)
 {
+        *p->addr = BREAKPOINT_INSTRUCTION;
+        flush_icache_range((unsigned long) p->addr,
+                           (unsigned long) p->addr + sizeof(kprobe_opcode_t));
 }
 
-static inline void disarm_kprobe(struct kprobe *p, struct pt_regs *regs)
+void arch_disarm_kprobe(struct kprobe *p)
 {
         *p->addr = p->opcode;
-        regs->nip = (unsigned long)p->addr;
+        flush_icache_range((unsigned long) p->addr,
+                           (unsigned long) p->addr + sizeof(kprobe_opcode_t));
+}
+
+void arch_remove_kprobe(struct kprobe *p)
+{
+        up(&kprobe_mutex);
+        free_insn_slot(p->ainsn.insn);
+        down(&kprobe_mutex);
 }
 
 static inline void prepare_singlestep(struct kprobe *p, struct pt_regs *regs)
 {
+        kprobe_opcode_t insn = *p->ainsn.insn;
+
         regs->msr |= MSR_SE;
-        /*single step inline if it a breakpoint instruction*/
-        if (p->opcode == BREAKPOINT_INSTRUCTION)
+
+        /* single step inline if it is a trap variant */
+        if (IS_TW(insn) || IS_TD(insn) || IS_TWI(insn) || IS_TDI(insn))
                 regs->nip = (unsigned long)p->addr;
         else
-                regs->nip = (unsigned long)&p->ainsn.insn;
+                regs->nip = (unsigned long)p->ainsn.insn;
+}
+
+static inline void save_previous_kprobe(void)
+{
+        kprobe_prev = current_kprobe;
+        kprobe_status_prev = kprobe_status;
+        kprobe_saved_msr_prev = kprobe_saved_msr;
+}
+
+static inline void restore_previous_kprobe(void)
+{
+        current_kprobe = kprobe_prev;
+        kprobe_status = kprobe_status_prev;
+        kprobe_saved_msr = kprobe_saved_msr_prev;
+}
+
+void arch_prepare_kretprobe(struct kretprobe *rp, struct pt_regs *regs)
+{
+        struct kretprobe_instance *ri;
+
+        if ((ri = get_free_rp_inst(rp)) != NULL) {
+                ri->rp = rp;
+                ri->task = current;
+                ri->ret_addr = (kprobe_opcode_t *)regs->link;
+
+                /* Replace the return addr with trampoline addr */
+                regs->link = (unsigned long)kretprobe_trampoline;
+                add_rp_inst(ri);
+        } else {
+                rp->nmissed++;
+        }
 }
 
 static inline int kprobe_handler(struct pt_regs *regs)
@@ -101,8 +157,19 @@ static inline int kprobe_handler(struct pt_regs *regs)
                                 unlock_kprobes();
                                 goto no_kprobe;
                         }
-                        disarm_kprobe(p, regs);
-                        ret = 1;
+                        /* We have reentered the kprobe_handler(), since
+                         * another probe was hit while within the handler.
+                         * We here save the original kprobes variables and
+                         * just single step on the instruction of the new probe
+                         * without calling any user handlers.
+                         */
+                        save_previous_kprobe();
+                        current_kprobe = p;
+                        kprobe_saved_msr = regs->msr;
+                        p->nmissed++;
+                        prepare_singlestep(p, regs);
+                        kprobe_status = KPROBE_REENTER;
+                        return 1;
                 } else {
                         p = current_kprobe;
                         if (p->break_handler && p->break_handler(p, regs)) {
@@ -162,6 +229,78 @@ no_kprobe:
 }
 
 /*
+ * Function return probe trampoline:
+ *      - init_kprobes() establishes a probepoint here
+ *      - When the probed function returns, this probe
+ *              causes the handlers to fire
+ */
+void kretprobe_trampoline_holder(void)
+{
+        asm volatile(".global kretprobe_trampoline\n"
+                        "kretprobe_trampoline:\n"
+                        "nop\n");
+}
+
+/*
+ * Called when the probe at kretprobe trampoline is hit
+ */
+int trampoline_probe_handler(struct kprobe *p, struct pt_regs *regs)
+{
+        struct kretprobe_instance *ri = NULL;
+        struct hlist_head *head;
+        struct hlist_node *node, *tmp;
+        unsigned long orig_ret_address = 0;
+        unsigned long trampoline_address =(unsigned long)&kretprobe_trampoline;
+
+        head = kretprobe_inst_table_head(current);
+
+        /*
+         * It is possible to have multiple instances associated with a given
+         * task either because an multiple functions in the call path
+         * have a return probe installed on them, and/or more then one return
+         * return probe was registered for a target function.
+         *
+         * We can handle this because:
+         *     - instances are always inserted at the head of the list
+         *     - when multiple return probes are registered for the same
+         *       function, the first instance's ret_addr will point to the
+         *       real return address, and all the rest will point to
+         *       kretprobe_trampoline
+         */
+        hlist_for_each_entry_safe(ri, node, tmp, head, hlist) {
+                if (ri->task != current)
+                        /* another task is sharing our hash bucket */
+                        continue;
+
+                if (ri->rp && ri->rp->handler)
+                        ri->rp->handler(ri, regs);
+
+                orig_ret_address = (unsigned long)ri->ret_addr;
+                recycle_rp_inst(ri);
+
+                if (orig_ret_address != trampoline_address)
+                        /*
+                         * This is the real return address. Any other
+                         * instances associated with this task are for
+                         * other calls deeper on the call stack
+                         */
+                        break;
+        }
+
+        BUG_ON(!orig_ret_address || (orig_ret_address == trampoline_address));
+        regs->nip = orig_ret_address;
+
+        unlock_kprobes();
+
+        /*
+         * By returning a non-zero value, we are telling
+         * kprobe_handler() that we have handled unlocking
+         * and re-enabling preemption.
+         */
+        return 1;
+}
+
+/*
  * Called after single-stepping.  p->addr is the address of the
  * instruction whose first byte has been replaced by the "breakpoint"
  * instruction.  To avoid the SMP problems that can occur when we
@@ -172,9 +311,10 @@ no_kprobe:
 static void resume_execution(struct kprobe *p, struct pt_regs *regs)
 {
         int ret;
+        unsigned int insn = *p->ainsn.insn;
 
         regs->nip = (unsigned long)p->addr;
-        ret = emulate_step(regs, p->ainsn.insn[0]);
+        ret = emulate_step(regs, insn);
         if (ret == 0)
                 regs->nip = (unsigned long)p->addr + 4;
 }
@@ -184,13 +324,21 @@ static inline int post_kprobe_handler(struct pt_regs *regs)
         if (!kprobe_running())
                 return 0;
 
-        if (current_kprobe->post_handler)
+        if ((kprobe_status != KPROBE_REENTER) && current_kprobe->post_handler) {
+                kprobe_status = KPROBE_HIT_SSDONE;
                 current_kprobe->post_handler(current_kprobe, regs, 0);
+        }
 
         resume_execution(current_kprobe, regs);
         regs->msr |= kprobe_saved_msr;
 
+        /*Restore back the original saved kprobes variables and continue. */
+        if (kprobe_status == KPROBE_REENTER) {
+                restore_previous_kprobe();
+                goto out;
+        }
         unlock_kprobes();
+out:
         preempt_enable_no_resched();
 
         /*
@@ -290,3 +438,13 @@ int longjmp_break_handler(struct kprobe *p, struct pt_regs *regs)
         memcpy(regs, &jprobe_saved_regs, sizeof(struct pt_regs));
         return 1;
 }
+
+static struct kprobe trampoline_p = {
+        .addr = (kprobe_opcode_t *) &kretprobe_trampoline,
+        .pre_handler = trampoline_probe_handler
+};
+
+int __init arch_init(void)
+{
+        return register_kprobe(&trampoline_p);
+}
diff --git a/arch/ppc64/kernel/lparcfg.c b/arch/ppc64/kernel/lparcfg.c
index a8fd32df848b..02e96627fa66 100644
--- a/arch/ppc64/kernel/lparcfg.c
+++ b/arch/ppc64/kernel/lparcfg.c
@@ -28,12 +28,13 @@
 #include <asm/uaccess.h>
 #include <asm/iSeries/HvLpConfig.h>
 #include <asm/lppaca.h>
-#include <asm/iSeries/LparData.h>
 #include <asm/hvcall.h>
 #include <asm/cputable.h>
 #include <asm/rtas.h>
 #include <asm/system.h>
 #include <asm/time.h>
+#include <asm/iSeries/ItExtVpdPanel.h>
+#include <asm/prom.h>
 
 #define MODULE_VERS "1.6"
 #define MODULE_NAME "lparcfg"
diff --git a/arch/ppc64/kernel/machine_kexec.c b/arch/ppc64/kernel/machine_kexec.c
new file mode 100644
index 000000000000..fdb2fc649d72
--- /dev/null
+++ b/arch/ppc64/kernel/machine_kexec.c
@@ -0,0 +1,302 @@
+/*
+ * machine_kexec.c - handle transition of Linux booting another kernel
+ *
+ * Copyright (C) 2004-2005, IBM Corp.
+ *
+ * Created by: Milton D Miller II
+ *
+ * This source code is licensed under the GNU General Public License,
+ * Version 2.  See the file COPYING for more details.
+ */
+
+
+#include <linux/cpumask.h>
+#include <linux/kexec.h>
+#include <linux/smp.h>
+#include <linux/thread_info.h>
+#include <linux/errno.h>
+
+#include <asm/page.h>
+#include <asm/current.h>
+#include <asm/machdep.h>
+#include <asm/cacheflush.h>
+#include <asm/paca.h>
+#include <asm/mmu.h>
+#include <asm/sections.h>       /* _end */
+#include <asm/prom.h>
+
+#define HASH_GROUP_SIZE 0x80    /* size of each hash group, asm/mmu.h */
+
+/* Have this around till we move it into crash specific file */
+note_buf_t crash_notes[NR_CPUS];
+
+/* Dummy for now. Not sure if we need to have a crash shutdown in here
+ * and if what it will achieve. Letting it be now to compile the code
+ * in generic kexec environment
+ */
+void machine_crash_shutdown(struct pt_regs *regs)
+{
+        /* do nothing right now */
+        /* smp_relase_cpus() if we want smp on panic kernel */
+        /* cpu_irq_down to isolate us until we are ready */
+}
+
+int machine_kexec_prepare(struct kimage *image)
+{
+        int i;
+        unsigned long begin, end;       /* limits of segment */
+        unsigned long low, high;        /* limits of blocked memory range */
+        struct device_node *node;
+        unsigned long *basep;
+        unsigned int *sizep;
+
+        if (!ppc_md.hpte_clear_all)
+                return -ENOENT;
+
+        /*
+         * Since we use the kernel fault handlers and paging code to
+         * handle the virtual mode, we must make sure no destination
+         * overlaps kernel static data or bss.
+         */
+        for (i = 0; i < image->nr_segments; i++)
+                if (image->segment[i].mem < __pa(_end))
+                        return -ETXTBSY;
+
+        /*
+         * For non-LPAR, we absolutely can not overwrite the mmu hash
+         * table, since we are still using the bolted entries in it to
+         * do the copy.  Check that here.
+         *
+         * It is safe if the end is below the start of the blocked
+         * region (end <= low), or if the beginning is after the
+         * end of the blocked region (begin >= high).  Use the
+         * boolean identity !(a || b)  === (!a && !b).
+         */
+        if (htab_address) {
+                low = __pa(htab_address);
+                high = low + (htab_hash_mask + 1) * HASH_GROUP_SIZE;
+
+                for (i = 0; i < image->nr_segments; i++) {
+                        begin = image->segment[i].mem;
+                        end = begin + image->segment[i].memsz;
+
+                        if ((begin < high) && (end > low))
+                                return -ETXTBSY;
+                }
+        }
+
+        /* We also should not overwrite the tce tables */
+        for (node = of_find_node_by_type(NULL, "pci"); node != NULL;
+                        node = of_find_node_by_type(node, "pci")) {
+                basep = (unsigned long *)get_property(node, "linux,tce-base",
+                                                        NULL);
+                sizep = (unsigned int *)get_property(node, "linux,tce-size",
+                                                        NULL);
+                if (basep == NULL || sizep == NULL)
+                        continue;
+
+                low = *basep;
+                high = low + (*sizep);
+
+                for (i = 0; i < image->nr_segments; i++) {
+                        begin = image->segment[i].mem;
+                        end = begin + image->segment[i].memsz;
+
+                        if ((begin < high) && (end > low))
+                                return -ETXTBSY;
+                }
+        }
+
+        return 0;
+}
+
+void machine_kexec_cleanup(struct kimage *image)
+{
+        /* we do nothing in prepare that needs to be undone */
+}
+
+#define IND_FLAGS (IND_DESTINATION | IND_INDIRECTION | IND_DONE | IND_SOURCE)
+
+static void copy_segments(unsigned long ind)
+{
+        unsigned long entry;
+        unsigned long *ptr;
+        void *dest;
+        void *addr;
+
+        /*
+         * We rely on kexec_load to create a lists that properly
+         * initializes these pointers before they are used.
+         * We will still crash if the list is wrong, but at least
+         * the compiler will be quiet.
+         */
+        ptr = NULL;
+        dest = NULL;
+
+        for (entry = ind; !(entry & IND_DONE); entry = *ptr++) {
+                addr = __va(entry & PAGE_MASK);
+
+                switch (entry & IND_FLAGS) {
+                case IND_DESTINATION:
+                        dest = addr;
+                        break;
+                case IND_INDIRECTION:
+                        ptr = addr;
+                        break;
+                case IND_SOURCE:
+                        copy_page(dest, addr);
+                        dest += PAGE_SIZE;
+                }
+        }
+}
+
+void kexec_copy_flush(struct kimage *image)
+{
+        long i, nr_segments = image->nr_segments;
+        struct  kexec_segment ranges[KEXEC_SEGMENT_MAX];
+
+        /* save the ranges on the stack to efficiently flush the icache */
+        memcpy(ranges, image->segment, sizeof(ranges));
+
+        /*
+         * After this call we may not use anything allocated in dynamic
+         * memory, including *image.
+         *
+         * Only globals and the stack are allowed.
+         */
+        copy_segments(image->head);
+
+        /*
+         * we need to clear the icache for all dest pages sometime,
+         * including ones that were in place on the original copy
+         */
+        for (i = 0; i < nr_segments; i++)
+                flush_icache_range(ranges[i].mem + KERNELBASE,
+                                ranges[i].mem + KERNELBASE +
+                                ranges[i].memsz);
+}
+
+#ifdef CONFIG_SMP
+
+/* FIXME: we should schedule this function to be called on all cpus based
+ * on calling the interrupts, but we would like to call it off irq level
+ * so that the interrupt controller is clean.
+ */
+void kexec_smp_down(void *arg)
+{
+        if (ppc_md.cpu_irq_down)
+                ppc_md.cpu_irq_down();
+
+        local_irq_disable();
+        kexec_smp_wait();
+        /* NOTREACHED */
+}
+
+static void kexec_prepare_cpus(void)
+{
+        int my_cpu, i, notified=-1;
+
+        smp_call_function(kexec_smp_down, NULL, 0, /* wait */0);
+        my_cpu = get_cpu();
+
+        /* check the others cpus are now down (via paca hw cpu id == -1) */
+        for (i=0; i < NR_CPUS; i++) {
+                if (i == my_cpu)
+                        continue;
+
+                while (paca[i].hw_cpu_id != -1) {
+                        if (!cpu_possible(i)) {
+                                printk("kexec: cpu %d hw_cpu_id %d is not"
+                                                " possible, ignoring\n",
+                                                i, paca[i].hw_cpu_id);
+                                break;
+                        }
+                        if (!cpu_online(i)) {
+                                /* Fixme: this can be spinning in
+                                 * pSeries_secondary_wait with a paca
+                                 * waiting for it to go online.
+                                 */
+                                printk("kexec: cpu %d hw_cpu_id %d is not"
+                                                " online, ignoring\n",
+                                                i, paca[i].hw_cpu_id);
+                                break;
+                        }
+                        if (i != notified) {
+                                printk( "kexec: waiting for cpu %d (physical"
+                                                " %d) to go down\n",
+                                                i, paca[i].hw_cpu_id);
+                                notified = i;
+                        }
+                }
+        }
+
+        /* after we tell the others to go down */
+        if (ppc_md.cpu_irq_down)
+                ppc_md.cpu_irq_down();
+
+        put_cpu();
+
+        local_irq_disable();
+}
+
+#else /* ! SMP */
+
+static void kexec_prepare_cpus(void)
+{
+        /*
+         * move the secondarys to us so that we can copy
+         * the new kernel 0-0x100 safely
+         *
+         * do this if kexec in setup.c ?
+         */
+        smp_relase_cpus();
+        if (ppc_md.cpu_irq_down)
+                ppc_md.cpu_irq_down();
+        local_irq_disable();
+}
+
+#endif /* SMP */
+
+/*
+ * kexec thread structure and stack.
+ *
+ * We need to make sure that this is 16384-byte aligned due to the
+ * way process stacks are handled.  It also must be statically allocated
+ * or allocated as part of the kimage, because everything else may be
+ * overwritten when we copy the kexec image.  We piggyback on the
+ * "init_task" linker section here to statically allocate a stack.
+ *
+ * We could use a smaller stack if we don't care about anything using
+ * current, but that audit has not been performed.
+ */
+union thread_union kexec_stack
+        __attribute__((__section__(".data.init_task"))) = { };
+
+/* Our assembly helper, in kexec_stub.S */
+extern NORET_TYPE void kexec_sequence(void *newstack, unsigned long start,
+                                        void *image, void *control,
+                                        void (*clear_all)(void)) ATTRIB_NORET;
+
+/* too late to fail here */
+void machine_kexec(struct kimage *image)
+{
+
+        /* prepare control code if any */
+
+        /* shutdown other cpus into our wait loop and quiesce interrupts */
+        kexec_prepare_cpus();
+
+        /* switch to a staticly allocated stack.  Based on irq stack code.
+         * XXX: the task struct will likely be invalid once we do the copy!
+         */
+        kexec_stack.thread_info.task = current_thread_info()->task;
+        kexec_stack.thread_info.flags = 0;
+
+        /* Some things are best done in assembly.  Finding globals with
+         * a toc is easier in C, so pass in what we can.
+         */
+        kexec_sequence(&kexec_stack, image->start, image,
+                        page_address(image->control_code_page),
+                        ppc_md.hpte_clear_all);
+        /* NOTREACHED */
+}
diff --git a/arch/ppc64/kernel/maple_setup.c b/arch/ppc64/kernel/maple_setup.c
index 8cf95a27178e..da8900b51f40 100644
--- a/arch/ppc64/kernel/maple_setup.c
+++ b/arch/ppc64/kernel/maple_setup.c
@@ -78,17 +78,77 @@ extern int maple_pci_get_legacy_ide_irq(struct pci_dev *dev, int channel);
 extern void generic_find_legacy_serial_ports(u64 *physport,
                 unsigned int *default_speed);
 
-
 static void maple_restart(char *cmd)
 {
+        unsigned int maple_nvram_base;
+        unsigned int maple_nvram_offset;
+        unsigned int maple_nvram_command;
+        struct device_node *rtcs;
+
+        /* find NVRAM device */
+        rtcs = find_compatible_devices("nvram", "AMD8111");
+        if (rtcs && rtcs->addrs) {
+                maple_nvram_base = rtcs->addrs[0].address;
+        } else {
+                printk(KERN_EMERG "Maple: Unable to find NVRAM\n");
+                printk(KERN_EMERG "Maple: Manual Restart Required\n");
+                return;
+        }
+
+        /* find service processor device */
+        rtcs = find_devices("service-processor");
+        if (!rtcs) {
+                printk(KERN_EMERG "Maple: Unable to find Service Processor\n");
+                printk(KERN_EMERG "Maple: Manual Restart Required\n");
+                return;
+        }
+        maple_nvram_offset = *(unsigned int*) get_property(rtcs,
+                        "restart-addr", NULL);
+        maple_nvram_command = *(unsigned int*) get_property(rtcs,
+                        "restart-value", NULL);
+
+        /* send command */
+        outb_p(maple_nvram_command, maple_nvram_base + maple_nvram_offset);
+        for (;;) ;
 }
 
 static void maple_power_off(void)
 {
+        unsigned int maple_nvram_base;
+        unsigned int maple_nvram_offset;
+        unsigned int maple_nvram_command;
+        struct device_node *rtcs;
+
+        /* find NVRAM device */
+        rtcs = find_compatible_devices("nvram", "AMD8111");
+        if (rtcs && rtcs->addrs) {
+                maple_nvram_base = rtcs->addrs[0].address;
+        } else {
+                printk(KERN_EMERG "Maple: Unable to find NVRAM\n");
+                printk(KERN_EMERG "Maple: Manual Power-Down Required\n");
+                return;
+        }
+
+        /* find service processor device */
+        rtcs = find_devices("service-processor");
+        if (!rtcs) {
+                printk(KERN_EMERG "Maple: Unable to find Service Processor\n");
+                printk(KERN_EMERG "Maple: Manual Power-Down Required\n");
+                return;
+        }
+        maple_nvram_offset = *(unsigned int*) get_property(rtcs,
+                        "power-off-addr", NULL);
+        maple_nvram_command = *(unsigned int*) get_property(rtcs,
+                        "power-off-value", NULL);
+
+        /* send command */
+        outb_p(maple_nvram_command, maple_nvram_base + maple_nvram_offset);
+        for (;;) ;
 }
 
 static void maple_halt(void)
 {
+        maple_power_off();
 }
 
 #ifdef CONFIG_SMP
@@ -235,6 +295,6 @@ struct machdep_calls __initdata maple_md = {
         .get_boot_time          = maple_get_boot_time,
         .set_rtc_time           = maple_set_rtc_time,
         .get_rtc_time           = maple_get_rtc_time,
-        .calibrate_decr         = maple_calibrate_decr,
+        .calibrate_decr         = generic_calibrate_decr,
         .progress               = maple_progress,
 };
diff --git a/arch/ppc64/kernel/maple_time.c b/arch/ppc64/kernel/maple_time.c
index 07ce7895b43d..d65210abcd03 100644
--- a/arch/ppc64/kernel/maple_time.c
+++ b/arch/ppc64/kernel/maple_time.c
@@ -42,11 +42,8 @@
 #define DBG(x...)
 #endif
 
-extern void setup_default_decr(void);
 extern void GregorianDay(struct rtc_time * tm);
 
-extern unsigned long ppc_tb_freq;
-extern unsigned long ppc_proc_freq;
 static int maple_rtc_addr;
 
 static int maple_clock_read(int addr)
@@ -176,51 +173,3 @@ void __init maple_get_boot_time(struct rtc_time *tm)
         maple_get_rtc_time(tm);
 }
 
-/* XXX FIXME: Some sane defaults: 125 MHz timebase, 1GHz processor */
-#define DEFAULT_TB_FREQ         125000000UL
-#define DEFAULT_PROC_FREQ       (DEFAULT_TB_FREQ * 8)
-
-void __init maple_calibrate_decr(void)
-{
-        struct device_node *cpu;
-        struct div_result divres;
-        unsigned int *fp = NULL;
-
-        /*
-         * The cpu node should have a timebase-frequency property
-         * to tell us the rate at which the decrementer counts.
-         */
-        cpu = of_find_node_by_type(NULL, "cpu");
-
-        ppc_tb_freq = DEFAULT_TB_FREQ;
-        if (cpu != 0)
-                fp = (unsigned int *)get_property(cpu, "timebase-frequency", NULL);
-        if (fp != NULL)
-                ppc_tb_freq = *fp;
-        else
-                printk(KERN_ERR "WARNING: Estimating decrementer frequency (not found)\n");
-        fp = NULL;
-        ppc_proc_freq = DEFAULT_PROC_FREQ;
-        if (cpu != 0)
-                fp = (unsigned int *)get_property(cpu, "clock-frequency", NULL);
-        if (fp != NULL)
-                ppc_proc_freq = *fp;
-        else
-                printk(KERN_ERR "WARNING: Estimating processor frequency (not found)\n");
-
-        of_node_put(cpu);
-
-        printk(KERN_INFO "time_init: decrementer frequency = %lu.%.6lu MHz\n",
-               ppc_tb_freq/1000000, ppc_tb_freq%1000000);
-        printk(KERN_INFO "time_init: processor frequency   = %lu.%.6lu MHz\n",
-               ppc_proc_freq/1000000, ppc_proc_freq%1000000);
-
-        tb_ticks_per_jiffy = ppc_tb_freq / HZ;
-        tb_ticks_per_sec = tb_ticks_per_jiffy * HZ;
-        tb_ticks_per_usec = ppc_tb_freq / 1000000;
-        tb_to_us = mulhwu_scale_factor(ppc_tb_freq, 1000000);
-        div128_by_32(1024*1024, 0, tb_ticks_per_sec, &divres);
-        tb_to_xs = divres.result_low;
-
-        setup_default_decr();
-}
diff --git a/arch/ppc64/kernel/mf.c b/arch/ppc64/kernel/mf.c
index 5aca7e8005a8..ef4a338ebd01 100644
--- a/arch/ppc64/kernel/mf.c
+++ b/arch/ppc64/kernel/mf.c
@@ -40,7 +40,6 @@
 #include <asm/iSeries/vio.h>
 #include <asm/iSeries/mf.h>
 #include <asm/iSeries/HvLpConfig.h>
-#include <asm/iSeries/ItSpCommArea.h>
 #include <asm/iSeries/ItLpQueue.h>
 
 /*
@@ -802,10 +801,8 @@ int mf_get_boot_rtc(struct rtc_time *tm)
                 return rc;
         /* We need to poll here as we are not yet taking interrupts */
         while (rtc_data.busy) {
-                extern unsigned long lpevent_count;
-                struct ItLpQueue *lpq = get_paca()->lpqueue_ptr;
-                if (lpq && ItLpQueue_isLpIntPending(lpq))
-                        lpevent_count += ItLpQueue_process(lpq, NULL);
+                if (hvlpevent_is_pending())
+                        process_hvlpevents(NULL);
         }
         return rtc_set_tm(rtc_data.rc, rtc_data.ce_msg.ce_msg, tm);
 }
diff --git a/arch/ppc64/kernel/misc.S b/arch/ppc64/kernel/misc.S
index e3c73b3425dc..f3dea0c5a88c 100644
--- a/arch/ppc64/kernel/misc.S
+++ b/arch/ppc64/kernel/misc.S
@@ -680,6 +680,177 @@ _GLOBAL(kernel_thread)
         ld      r30,-16(r1)
         blr
 
+/* kexec_wait(phys_cpu)
+ *
+ * wait for the flag to change, indicating this kernel is going away but
+ * the slave code for the next one is at addresses 0 to 100.
+ *
+ * This is used by all slaves.
+ *
+ * Physical (hardware) cpu id should be in r3.
+ */
+_GLOBAL(kexec_wait)
+        bl      1f
+1:      mflr    r5
+        addi    r5,r5,kexec_flag-1b
+
+99:     HMT_LOW
+#ifdef CONFIG_KEXEC             /* use no memory without kexec */
+        lwz     r4,0(r5)
+        cmpwi   0,r4,0
+        bnea    0x60
+#endif
+        b       99b
+
+/* this can be in text because we won't change it until we are
+ * running in real anyways
+ */
+kexec_flag:
+        .long   0
+
+
+#ifdef CONFIG_KEXEC
+
+/* kexec_smp_wait(void)
+ *
+ * call with interrupts off
+ * note: this is a terminal routine, it does not save lr
+ *
+ * get phys id from paca
+ * set paca id to -1 to say we got here
+ * switch to real mode
+ * join other cpus in kexec_wait(phys_id)
+ */
+_GLOBAL(kexec_smp_wait)
+        lhz     r3,PACAHWCPUID(r13)
+        li      r4,-1
+        sth     r4,PACAHWCPUID(r13)     /* let others know we left */
+        bl      real_mode
+        b       .kexec_wait
+
+/*
+ * switch to real mode (turn mmu off)
+ * we use the early kernel trick that the hardware ignores bits
+ * 0 and 1 (big endian) of the effective address in real mode
+ *
+ * don't overwrite r3 here, it is live for kexec_wait above.
+ */
+real_mode:      /* assume normal blr return */
+1:      li      r9,MSR_RI
+        li      r10,MSR_DR|MSR_IR
+        mflr    r11             /* return address to SRR0 */
+        mfmsr   r12
+        andc    r9,r12,r9
+        andc    r10,r12,r10
+
+        mtmsrd  r9,1
+        mtspr   SPRN_SRR1,r10
+        mtspr   SPRN_SRR0,r11
+        rfid
+
+
+/*
+ * kexec_sequence(newstack, start, image, control, clear_all())
+ *
+ * does the grungy work with stack switching and real mode switches
+ * also does simple calls to other code
+ */
+
+_GLOBAL(kexec_sequence)
+        mflr    r0
+        std     r0,16(r1)
+
+        /* switch stacks to newstack -- &kexec_stack.stack */
+        stdu    r1,THREAD_SIZE-112(r3)
+        mr      r1,r3
+
+        li      r0,0
+        std     r0,16(r1)
+
+        /* save regs for local vars on new stack.
+         * yes, we won't go back, but ...
+         */
+        std     r31,-8(r1)
+        std     r30,-16(r1)
+        std     r29,-24(r1)
+        std     r28,-32(r1)
+        std     r27,-40(r1)
+        std     r26,-48(r1)
+        std     r25,-56(r1)
+
+        stdu    r1,-112-64(r1)
+
+        /* save args into preserved regs */
+        mr      r31,r3                  /* newstack (both) */
+        mr      r30,r4                  /* start (real) */
+        mr      r29,r5                  /* image (virt) */
+        mr      r28,r6                  /* control, unused */
+        mr      r27,r7                  /* clear_all() fn desc */
+        mr      r26,r8                  /* spare */
+        lhz     r25,PACAHWCPUID(r13)    /* get our phys cpu from paca */
+
+        /* disable interrupts, we are overwriting kernel data next */
+        mfmsr   r3
+        rlwinm  r3,r3,0,17,15
+        mtmsrd  r3,1
+
+        /* copy dest pages, flush whole dest image */
+        mr      r3,r29
+        bl      .kexec_copy_flush       /* (image) */
+
+        /* turn off mmu */
+        bl      real_mode
+
+        /* clear out hardware hash page table and tlb */
+        ld      r5,0(r27)               /* deref function descriptor */
+        mtctr   r5
+        bctrl                           /* ppc_md.hash_clear_all(void); */
+
+/*
+ *   kexec image calling is:
+ *      the first 0x100 bytes of the entry point are copied to 0
+ *
+ *      all slaves branch to slave = 0x60 (absolute)
+ *              slave(phys_cpu_id);
+ *
+ *      master goes to start = entry point
+ *              start(phys_cpu_id, start, 0);
+ *
+ *
+ *   a wrapper is needed to call existing kernels, here is an approximate
+ *   description of one method:
+ *
+ * v2: (2.6.10)
+ *   start will be near the boot_block (maybe 0x100 bytes before it?)
+ *   it will have a 0x60, which will b to boot_block, where it will wait
+ *   and 0 will store phys into struct boot-block and load r3 from there,
+ *   copy kernel 0-0x100 and tell slaves to back down to 0x60 again
+ *
+ * v1: (2.6.9)
+ *    boot block will have all cpus scanning device tree to see if they
+ *    are the boot cpu ?????
+ *    other device tree differences (prop sizes, va vs pa, etc)...
+ */
+
+        /* copy  0x100 bytes starting at start to 0 */
+        li      r3,0
+        mr      r4,r30
+        li      r5,0x100
+        li      r6,0
+        bl      .copy_and_flush /* (dest, src, copy limit, start offset) */
+1:      /* assume normal blr return */
+
+        /* release other cpus to the new kernel secondary start at 0x60 */
+        mflr    r5
+        li      r6,1
+        stw     r6,kexec_flag-1b(5)
+        mr      r3,r25  # my phys cpu
+        mr      r4,r30  # start, aka phys mem offset
+        mtlr    4
+        li      r5,0
+        blr     /* image->start(physid, image->start, 0); */
+#endif /* CONFIG_KEXEC */
+
 /* Why isn't this a) automatic, b) written in 'C'? */   
         .balign 8
 _GLOBAL(sys_call_table32)
@@ -951,7 +1122,7 @@ _GLOBAL(sys_call_table32)
         .llong .compat_sys_mq_timedreceive /* 265 */
         .llong .compat_sys_mq_notify
         .llong .compat_sys_mq_getsetattr
-        .llong .sys_ni_syscall          /* 268 reserved for sys_kexec_load */
+        .llong .compat_sys_kexec_load
         .llong .sys32_add_key
         .llong .sys32_request_key
         .llong .compat_sys_keyctl
@@ -1227,7 +1398,7 @@ _GLOBAL(sys_call_table)
         .llong .sys_mq_timedreceive     /* 265 */
         .llong .sys_mq_notify
         .llong .sys_mq_getsetattr
-        .llong .sys_ni_syscall          /* 268 reserved for sys_kexec_load */
+        .llong .sys_kexec_load
         .llong .sys_add_key
         .llong .sys_request_key         /* 270 */
         .llong .sys_keyctl
diff --git a/arch/ppc64/kernel/mpic.c b/arch/ppc64/kernel/mpic.c
index 593ea5b82afa..e8fbab1df37f 100644
--- a/arch/ppc64/kernel/mpic.c
+++ b/arch/ppc64/kernel/mpic.c
@@ -792,6 +792,35 @@ void mpic_setup_this_cpu(void)
 #endif /* CONFIG_SMP */
 }
 
+/*
+ * XXX: someone who knows mpic should check this.
+ * do we need to eoi the ipi here (see xics comments)?
+ * or can we reset the mpic in the new kernel?
+ */
+void mpic_teardown_this_cpu(void)
+{
+        struct mpic *mpic = mpic_primary;
+        unsigned long flags;
+        u32 msk = 1 << hard_smp_processor_id();
+        unsigned int i;
+
+        BUG_ON(mpic == NULL);
+
+        DBG("%s: teardown_this_cpu(%d)\n", mpic->name, hard_smp_processor_id());
+        spin_lock_irqsave(&mpic_lock, flags);
+
+        /* let the mpic know we don't want intrs.  */
+        for (i = 0; i < mpic->num_sources ; i++)
+                mpic_irq_write(i, MPIC_IRQ_DESTINATION,
+                        mpic_irq_read(i, MPIC_IRQ_DESTINATION) & ~msk);
+
+        /* Set current processor priority to max */
+        mpic_cpu_write(MPIC_CPU_CURRENT_TASK_PRI, 0xf);
+
+        spin_unlock_irqrestore(&mpic_lock, flags);
+}
+
+
 void mpic_send_ipi(unsigned int ipi_no, unsigned int cpu_mask)
 {
         struct mpic *mpic = mpic_primary;
diff --git a/arch/ppc64/kernel/mpic.h b/arch/ppc64/kernel/mpic.h
index 571b3c99e062..99fbbc9a084c 100644
--- a/arch/ppc64/kernel/mpic.h
+++ b/arch/ppc64/kernel/mpic.h
@@ -255,6 +255,9 @@ extern unsigned int mpic_irq_get_priority(unsigned int irq);
 /* Setup a non-boot CPU */
 extern void mpic_setup_this_cpu(void);
 
+/* Clean up for kexec (or cpu offline or ...) */
+extern void mpic_teardown_this_cpu(void);
+
 /* Request IPIs on primary mpic */
 extern void mpic_request_ipis(void);
 
@@ -265,3 +268,6 @@ extern void mpic_send_ipi(unsigned int ipi_no, unsigned int cpu_mask);
 extern int mpic_get_one_irq(struct mpic *mpic, struct pt_regs *regs);
 /* This one gets to the primary mpic */
 extern int mpic_get_irq(struct pt_regs *regs);
+
+/* global mpic for pSeries */
+extern struct mpic *pSeries_mpic;
diff --git a/arch/ppc64/kernel/nvram.c b/arch/ppc64/kernel/nvram.c
index 4e71781a4414..4fb1a9f5060d 100644
--- a/arch/ppc64/kernel/nvram.c
+++ b/arch/ppc64/kernel/nvram.c
@@ -338,9 +338,8 @@ static int nvram_remove_os_partition(void)
  */
 static int nvram_create_os_partition(void)
 {
-        struct list_head * p;
-        struct nvram_partition *part = NULL;
-        struct nvram_partition *new_part = NULL;
+        struct nvram_partition *part;
+        struct nvram_partition *new_part;
         struct nvram_partition *free_part = NULL;
         int seq_init[2] = { 0, 0 };
         loff_t tmp_index;
@@ -349,8 +348,7 @@ static int nvram_create_os_partition(void)
         
         /* Find a free partition that will give us the maximum needed size 
            If can't find one that will give us the minimum size needed */
-        list_for_each(p, &nvram_part->partition) {
-                part = list_entry(p, struct nvram_partition, partition);
+        list_for_each_entry(part, &nvram_part->partition, partition) {
                 if (part->header.signature != NVRAM_SIG_FREE)
                         continue;
 
diff --git a/arch/ppc64/kernel/of_device.c b/arch/ppc64/kernel/of_device.c
index f4c825a69fa0..66bd5ab7c25a 100644
--- a/arch/ppc64/kernel/of_device.c
+++ b/arch/ppc64/kernel/of_device.c
@@ -161,7 +161,7 @@ void of_unregister_driver(struct of_platform_driver *drv)
 }
 
 
-static ssize_t dev_show_devspec(struct device *dev, char *buf)
+static ssize_t dev_show_devspec(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct of_device *ofdev;
 
diff --git a/arch/ppc64/kernel/pSeries_pci.c b/arch/ppc64/kernel/pSeries_pci.c
index 0b1cca281408..1f5f141fb7a1 100644
--- a/arch/ppc64/kernel/pSeries_pci.c
+++ b/arch/ppc64/kernel/pSeries_pci.c
@@ -1,13 +1,11 @@
 /*
- * pSeries_pci.c
+ * arch/ppc64/kernel/pSeries_pci.c
  *
  * Copyright (C) 2001 Dave Engebretsen, IBM Corporation
  * Copyright (C) 2003 Anton Blanchard <anton@au.ibm.com>, IBM
  *
  * pSeries specific routines for PCI.
  * 
- * Based on code from pci.c and chrp_pci.c
- *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
@@ -23,430 +21,18 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 
+#include <linux/init.h>
+#include <linux/ioport.h>
 #include <linux/kernel.h>
-#include <linux/threads.h>
 #include <linux/pci.h>
 #include <linux/string.h>
-#include <linux/init.h>
-#include <linux/bootmem.h>
 
-#include <asm/io.h>
-#include <asm/pgtable.h>
-#include <asm/irq.h>
-#include <asm/prom.h>
-#include <asm/machdep.h>
 #include <asm/pci-bridge.h>
-#include <asm/iommu.h>
-#include <asm/rtas.h>
+#include <asm/prom.h>
 
-#include "mpic.h"
 #include "pci.h"
 
-/* RTAS tokens */
-static int read_pci_config;
-static int write_pci_config;
-static int ibm_read_pci_config;
-static int ibm_write_pci_config;
-
-static int s7a_workaround;
-
-extern struct mpic *pSeries_mpic;
-
-static int config_access_valid(struct device_node *dn, int where)
-{
-        if (where < 256)
-                return 1;
-        if (where < 4096 && dn->pci_ext_config_space)
-                return 1;
-
-        return 0;
-}
-
-static int rtas_read_config(struct device_node *dn, int where, int size, u32 *val)
-{
-        int returnval = -1;
-        unsigned long buid, addr;
-        int ret;
-
-        if (!dn)
-                return PCIBIOS_DEVICE_NOT_FOUND;
-        if (!config_access_valid(dn, where))
-                return PCIBIOS_BAD_REGISTER_NUMBER;
-
-        addr = ((where & 0xf00) << 20) | (dn->busno << 16) |
-                (dn->devfn << 8) | (where & 0xff);
-        buid = dn->phb->buid;
-        if (buid) {
-                ret = rtas_call(ibm_read_pci_config, 4, 2, &returnval,
-                                addr, buid >> 32, buid & 0xffffffff, size);
-        } else {
-                ret = rtas_call(read_pci_config, 2, 2, &returnval, addr, size);
-        }
-        *val = returnval;
-
-        if (ret)
-                return PCIBIOS_DEVICE_NOT_FOUND;
-
-        if (returnval == EEH_IO_ERROR_VALUE(size)
-            && eeh_dn_check_failure (dn, NULL))
-                return PCIBIOS_DEVICE_NOT_FOUND;
-
-        return PCIBIOS_SUCCESSFUL;
-}
-
-static int rtas_pci_read_config(struct pci_bus *bus,
-                                unsigned int devfn,
-                                int where, int size, u32 *val)
-{
-        struct device_node *busdn, *dn;
-
-        if (bus->self)
-                busdn = pci_device_to_OF_node(bus->self);
-        else
-                busdn = bus->sysdata;   /* must be a phb */
-
-        /* Search only direct children of the bus */
-        for (dn = busdn->child; dn; dn = dn->sibling)
-                if (dn->devfn == devfn)
-                        return rtas_read_config(dn, where, size, val);
-        return PCIBIOS_DEVICE_NOT_FOUND;
-}
-
-static int rtas_write_config(struct device_node *dn, int where, int size, u32 val)
-{
-        unsigned long buid, addr;
-        int ret;
-
-        if (!dn)
-                return PCIBIOS_DEVICE_NOT_FOUND;
-        if (!config_access_valid(dn, where))
-                return PCIBIOS_BAD_REGISTER_NUMBER;
-
-        addr = ((where & 0xf00) << 20) | (dn->busno << 16) |
-                (dn->devfn << 8) | (where & 0xff);
-        buid = dn->phb->buid;
-        if (buid) {
-                ret = rtas_call(ibm_write_pci_config, 5, 1, NULL, addr, buid >> 32, buid & 0xffffffff, size, (ulong) val);
-        } else {
-                ret = rtas_call(write_pci_config, 3, 1, NULL, addr, size, (ulong)val);
-        }
-
-        if (ret)
-                return PCIBIOS_DEVICE_NOT_FOUND;
-
-        return PCIBIOS_SUCCESSFUL;
-}
-
-static int rtas_pci_write_config(struct pci_bus *bus,
-                                 unsigned int devfn,
-                                 int where, int size, u32 val)
-{
-        struct device_node *busdn, *dn;
-
-        if (bus->self)
-                busdn = pci_device_to_OF_node(bus->self);
-        else
-                busdn = bus->sysdata;   /* must be a phb */
-
-        /* Search only direct children of the bus */
-        for (dn = busdn->child; dn; dn = dn->sibling)
-                if (dn->devfn == devfn)
-                        return rtas_write_config(dn, where, size, val);
-        return PCIBIOS_DEVICE_NOT_FOUND;
-}
-
-struct pci_ops rtas_pci_ops = {
-        rtas_pci_read_config,
-        rtas_pci_write_config
-};
-
-int is_python(struct device_node *dev)
-{
-        char *model = (char *)get_property(dev, "model", NULL);
-
-        if (model && strstr(model, "Python"))
-                return 1;
-
-        return 0;
-}
-
-static int get_phb_reg_prop(struct device_node *dev,
-                            unsigned int addr_size_words,
-                            struct reg_property64 *reg)
-{
-        unsigned int *ui_ptr = NULL, len;
-
-        /* Found a PHB, now figure out where his registers are mapped. */
-        ui_ptr = (unsigned int *)get_property(dev, "reg", &len);
-        if (ui_ptr == NULL)
-                return 1;
-
-        if (addr_size_words == 1) {
-                reg->address = ((struct reg_property32 *)ui_ptr)->address;
-                reg->size    = ((struct reg_property32 *)ui_ptr)->size;
-        } else {
-                *reg = *((struct reg_property64 *)ui_ptr);
-        }
-
-        return 0;
-}
-
-static void python_countermeasures(struct device_node *dev,
-                                   unsigned int addr_size_words)
-{
-        struct reg_property64 reg_struct;
-        void __iomem *chip_regs;
-        volatile u32 val;
-
-        if (get_phb_reg_prop(dev, addr_size_words, &reg_struct))
-                return;
-
-        /* Python's register file is 1 MB in size. */
-        chip_regs = ioremap(reg_struct.address & ~(0xfffffUL), 0x100000);
-
-        /* 
-         * Firmware doesn't always clear this bit which is critical
-         * for good performance - Anton
-         */
-
-#define PRG_CL_RESET_VALID 0x00010000
-
-        val = in_be32(chip_regs + 0xf6030);
-        if (val & PRG_CL_RESET_VALID) {
-                printk(KERN_INFO "Python workaround: ");
-                val &= ~PRG_CL_RESET_VALID;
-                out_be32(chip_regs + 0xf6030, val);
-                /*
-                 * We must read it back for changes to
-                 * take effect
-                 */
-                val = in_be32(chip_regs + 0xf6030);
-                printk("reg0: %x\n", val);
-        }
-
-        iounmap(chip_regs);
-}
-
-void __init init_pci_config_tokens (void)
-{
-        read_pci_config = rtas_token("read-pci-config");
-        write_pci_config = rtas_token("write-pci-config");
-        ibm_read_pci_config = rtas_token("ibm,read-pci-config");
-        ibm_write_pci_config = rtas_token("ibm,write-pci-config");
-}
-
-unsigned long __devinit get_phb_buid (struct device_node *phb)
-{
-        int addr_cells;
-        unsigned int *buid_vals;
-        unsigned int len;
-        unsigned long buid;
-
-        if (ibm_read_pci_config == -1) return 0;
-
-        /* PHB's will always be children of the root node,
-         * or so it is promised by the current firmware. */
-        if (phb->parent == NULL)
-                return 0;
-        if (phb->parent->parent)
-                return 0;
-
-        buid_vals = (unsigned int *) get_property(phb, "reg", &len);
-        if (buid_vals == NULL)
-                return 0;
-
-        addr_cells = prom_n_addr_cells(phb);
-        if (addr_cells == 1) {
-                buid = (unsigned long) buid_vals[0];
-        } else {
-                buid = (((unsigned long)buid_vals[0]) << 32UL) |
-                        (((unsigned long)buid_vals[1]) & 0xffffffff);
-        }
-        return buid;
-}
-
-static int phb_set_bus_ranges(struct device_node *dev,
-                              struct pci_controller *phb)
-{
-        int *bus_range;
-        unsigned int len;
-
-        bus_range = (int *) get_property(dev, "bus-range", &len);
-        if (bus_range == NULL || len < 2 * sizeof(int)) {
-                return 1;
-        }
- 
-        phb->first_busno =  bus_range[0];
-        phb->last_busno  =  bus_range[1];
-
-        return 0;
-}
-
-static int __devinit setup_phb(struct device_node *dev,
-                               struct pci_controller *phb,
-                               unsigned int addr_size_words)
-{
-        pci_setup_pci_controller(phb);
-
-        if (is_python(dev))
-                python_countermeasures(dev, addr_size_words);
-
-        if (phb_set_bus_ranges(dev, phb))
-                return 1;
-
-        phb->arch_data = dev;
-        phb->ops = &rtas_pci_ops;
-        phb->buid = get_phb_buid(dev);
-
-        return 0;
-}
-
-static void __devinit add_linux_pci_domain(struct device_node *dev,
-                                           struct pci_controller *phb,
-                                           struct property *of_prop)
-{
-        memset(of_prop, 0, sizeof(struct property));
-        of_prop->name = "linux,pci-domain";
-        of_prop->length = sizeof(phb->global_number);
-        of_prop->value = (unsigned char *)&of_prop[1];
-        memcpy(of_prop->value, &phb->global_number, sizeof(phb->global_number));
-        prom_add_property(dev, of_prop);
-}
-
-static struct pci_controller * __init alloc_phb(struct device_node *dev,
-                                                unsigned int addr_size_words)
-{
-        struct pci_controller *phb;
-        struct property *of_prop;
-
-        phb = alloc_bootmem(sizeof(struct pci_controller));
-        if (phb == NULL)
-                return NULL;
-
-        of_prop = alloc_bootmem(sizeof(struct property) +
-                                sizeof(phb->global_number));
-        if (!of_prop)
-                return NULL;
-
-        if (setup_phb(dev, phb, addr_size_words))
-                return NULL;
-
-        add_linux_pci_domain(dev, phb, of_prop);
-
-        return phb;
-}
-
-static struct pci_controller * __devinit alloc_phb_dynamic(struct device_node *dev, unsigned int addr_size_words)
-{
-        struct pci_controller *phb;
-
-        phb = (struct pci_controller *)kmalloc(sizeof(struct pci_controller),
-                                               GFP_KERNEL);
-        if (phb == NULL)
-                return NULL;
-
-        if (setup_phb(dev, phb, addr_size_words))
-                return NULL;
-
-        phb->is_dynamic = 1;
-
-        /* TODO: linux,pci-domain? */
-
-        return phb;
-}
-
-unsigned long __init find_and_init_phbs(void)
-{
-        struct device_node *node;
-        struct pci_controller *phb;
-        unsigned int root_size_cells = 0;
-        unsigned int index;
-        unsigned int *opprop = NULL;
-        struct device_node *root = of_find_node_by_path("/");
-
-        if (ppc64_interrupt_controller == IC_OPEN_PIC) {
-                opprop = (unsigned int *)get_property(root,
-                                "platform-open-pic", NULL);
-        }
-
-        root_size_cells = prom_n_size_cells(root);
-
-        index = 0;
-
-        for (node = of_get_next_child(root, NULL);
-             node != NULL;
-             node = of_get_next_child(root, node)) {
-                if (node->type == NULL || strcmp(node->type, "pci") != 0)
-                        continue;
-
-                phb = alloc_phb(node, root_size_cells);
-                if (!phb)
-                        continue;
-
-                pci_process_bridge_OF_ranges(phb, node);
-                pci_setup_phb_io(phb, index == 0);
-
-                if (ppc64_interrupt_controller == IC_OPEN_PIC && pSeries_mpic) {
-                        int addr = root_size_cells * (index + 2) - 1;
-                        mpic_assign_isu(pSeries_mpic, index, opprop[addr]);
-                }
-
-                index++;
-        }
-
-        of_node_put(root);
-        pci_devs_phb_init();
-
-        /*
-         * pci_probe_only and pci_assign_all_buses can be set via properties
-         * in chosen.
-         */
-        if (of_chosen) {
-                int *prop;
-
-                prop = (int *)get_property(of_chosen, "linux,pci-probe-only",
-                                           NULL);
-                if (prop)
-                        pci_probe_only = *prop;
-
-                prop = (int *)get_property(of_chosen,
-                                           "linux,pci-assign-all-buses", NULL);
-                if (prop)
-                        pci_assign_all_buses = *prop;
-        }
-
-        return 0;
-}
-
-struct pci_controller * __devinit init_phb_dynamic(struct device_node *dn)
-{
-        struct device_node *root = of_find_node_by_path("/");
-        unsigned int root_size_cells = 0;
-        struct pci_controller *phb;
-        struct pci_bus *bus;
-        int primary;
-
-        root_size_cells = prom_n_size_cells(root);
-
-        primary = list_empty(&hose_list);
-        phb = alloc_phb_dynamic(dn, root_size_cells);
-        if (!phb)
-                return NULL;
-
-        pci_process_bridge_OF_ranges(phb, dn);
-
-        pci_setup_phb_io_dynamic(phb, primary);
-        of_node_put(root);
-
-        pci_devs_phb_init_dynamic(phb);
-        phb->last_busno = 0xff;
-        bus = pci_scan_bus(phb->first_busno, phb->ops, phb->arch_data);
-        phb->bus = bus;
-        phb->last_busno = bus->subordinate;
-
-        return phb;
-}
-EXPORT_SYMBOL(init_phb_dynamic);
+static int __initdata s7a_workaround = -1;
 
 #if 0
 void pcibios_name_device(struct pci_dev *dev)
@@ -474,11 +60,12 @@ void pcibios_name_device(struct pci_dev *dev)
 DECLARE_PCI_FIXUP_HEADER(PCI_ANY_ID, PCI_ANY_ID, pcibios_name_device);
 #endif
 
-static void check_s7a(void)
+static void __init check_s7a(void)
 {
         struct device_node *root;
         char *model;
 
+        s7a_workaround = 0;
         root = of_find_node_by_path("/");
         if (root) {
                 model = get_property(root, "model", NULL);
@@ -488,55 +75,23 @@ static void check_s7a(void)
         }
 }
 
-/* RPA-specific bits for removing PHBs */
-int pcibios_remove_root_bus(struct pci_controller *phb)
+void __devinit pSeries_irq_bus_setup(struct pci_bus *bus)
 {
-        struct pci_bus *b = phb->bus;
-        struct resource *res;
-        int rc, i;
-
-        res = b->resource[0];
-        if (!res->flags) {
-                printk(KERN_ERR "%s: no IO resource for PHB %s\n", __FUNCTION__,
-                                b->name);
-                return 1;
-        }
-
-        rc = unmap_bus_range(b);
-        if (rc) {
-                printk(KERN_ERR "%s: failed to unmap IO on bus %s\n",
-                        __FUNCTION__, b->name);
-                return 1;
-        }
+        struct pci_dev *dev;
 
-        if (release_resource(res)) {
-                printk(KERN_ERR "%s: failed to release IO on bus %s\n",
-                                __FUNCTION__, b->name);
-                return 1;
-        }
-
-        for (i = 1; i < 3; ++i) {
-                res = b->resource[i];
-                if (!res->flags && i == 0) {
-                        printk(KERN_ERR "%s: no MEM resource for PHB %s\n",
-                                __FUNCTION__, b->name);
-                        return 1;
-                }
-                if (res->flags && release_resource(res)) {
-                        printk(KERN_ERR
-                               "%s: failed to release IO %d on bus %s\n",
-                                __FUNCTION__, i, b->name);
-                        return 1;
+        if (s7a_workaround < 0)
+                check_s7a();
+        list_for_each_entry(dev, &bus->devices, bus_list) {
+                pci_read_irq_line(dev);
+                if (s7a_workaround) {
+                        if (dev->irq > 16) {
+                                dev->irq -= 3;
+                                pci_write_config_byte(dev, PCI_INTERRUPT_LINE,
+                                        dev->irq);
+                        }
                 }
         }
-
-        list_del(&phb->list_node);
-        if (phb->is_dynamic)
-                kfree(phb);
-
-        return 0;
 }
-EXPORT_SYMBOL(pcibios_remove_root_bus);
 
 static void __init pSeries_request_regions(void)
 {
@@ -553,20 +108,6 @@ static void __init pSeries_request_regions(void)
 
 void __init pSeries_final_fixup(void)
 {
-        struct pci_dev *dev = NULL;
-
-        check_s7a();
-
-        for_each_pci_dev(dev) {
-                pci_read_irq_line(dev);
-                if (s7a_workaround) {
-                        if (dev->irq > 16) {
-                                dev->irq -= 3;
-                                pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
-                        }
-                }
-        }
-
         phbs_remap_io();
         pSeries_request_regions();
 
diff --git a/arch/ppc64/kernel/pSeries_setup.c b/arch/ppc64/kernel/pSeries_setup.c
index 6c0d1d58a552..44d9af72d225 100644
--- a/arch/ppc64/kernel/pSeries_setup.c
+++ b/arch/ppc64/kernel/pSeries_setup.c
@@ -71,11 +71,6 @@
 #define DBG(fmt...)
 #endif
 
-extern void pSeries_final_fixup(void);
-
-extern void pSeries_get_boot_time(struct rtc_time *rtc_time);
-extern void pSeries_get_rtc_time(struct rtc_time *rtc_time);
-extern int  pSeries_set_rtc_time(struct rtc_time *rtc_time);
 extern void find_udbg_vterm(void);
 extern void system_reset_fwnmi(void);   /* from head.S */
 extern void machine_check_fwnmi(void);  /* from head.S */
@@ -84,9 +79,6 @@ extern void generic_find_legacy_serial_ports(u64 *physport,
 
 int fwnmi_active;  /* TRUE if an FWNMI handler is present */
 
-extern unsigned long ppc_proc_freq;
-extern unsigned long ppc_tb_freq;
-
 extern void pSeries_system_reset_exception(struct pt_regs *regs);
 extern int pSeries_machine_check_exception(struct pt_regs *regs);
 
@@ -195,14 +187,16 @@ static void __init pSeries_setup_arch(void)
 {
         /* Fixup ppc_md depending on the type of interrupt controller */
         if (ppc64_interrupt_controller == IC_OPEN_PIC) {
-                ppc_md.init_IRQ       = pSeries_init_mpic; 
+                ppc_md.init_IRQ       = pSeries_init_mpic;
                 ppc_md.get_irq        = mpic_get_irq;
+                ppc_md.cpu_irq_down   = mpic_teardown_this_cpu;
                 /* Allocate the mpic now, so that find_and_init_phbs() can
                  * fill the ISUs */
                 pSeries_setup_mpic();
         } else {
                 ppc_md.init_IRQ       = xics_init_IRQ;
                 ppc_md.get_irq        = xics_get_irq;
+                ppc_md.cpu_irq_down   = xics_teardown_cpu;
         }
 
 #ifdef CONFIG_SMP
@@ -381,171 +375,6 @@ static void __init pSeries_init_early(void)
 }
 
 
-static void pSeries_progress(char *s, unsigned short hex)
-{
-        struct device_node *root;
-        int width, *p;
-        char *os;
-        static int display_character, set_indicator;
-        static int max_width;
-        static DEFINE_SPINLOCK(progress_lock);
-        static int pending_newline = 0;  /* did last write end with unprinted newline? */
-
-        if (!rtas.base)
-                return;
-
-        if (max_width == 0) {
-                if ((root = find_path_device("/rtas")) &&
-                     (p = (unsigned int *)get_property(root,
-                                                       "ibm,display-line-length",
-                                                       NULL)))
-                        max_width = *p;
-                else
-                        max_width = 0x10;
-                display_character = rtas_token("display-character");
-                set_indicator = rtas_token("set-indicator");
-        }
-
-        if (display_character == RTAS_UNKNOWN_SERVICE) {
-                /* use hex display if available */
-                if (set_indicator != RTAS_UNKNOWN_SERVICE)
-                        rtas_call(set_indicator, 3, 1, NULL, 6, 0, hex);
-                return;
-        }
-
-        spin_lock(&progress_lock);
-
-        /*
-         * Last write ended with newline, but we didn't print it since
-         * it would just clear the bottom line of output. Print it now
-         * instead.
-         *
-         * If no newline is pending, print a CR to start output at the
-         * beginning of the line.
-         */
-        if (pending_newline) {
-                rtas_call(display_character, 1, 1, NULL, '\r');
-                rtas_call(display_character, 1, 1, NULL, '\n');
-                pending_newline = 0;
-        } else {
-                rtas_call(display_character, 1, 1, NULL, '\r');
-        }
- 
-        width = max_width;
-        os = s;
-        while (*os) {
-                if (*os == '\n' || *os == '\r') {
-                        /* Blank to end of line. */
-                        while (width-- > 0)
-                                rtas_call(display_character, 1, 1, NULL, ' ');
- 
-                        /* If newline is the last character, save it
-                         * until next call to avoid bumping up the
-                         * display output.
-                         */
-                        if (*os == '\n' && !os[1]) {
-                                pending_newline = 1;
-                                spin_unlock(&progress_lock);
-                                return;
-                        }
- 
-                        /* RTAS wants CR-LF, not just LF */
- 
-                        if (*os == '\n') {
-                                rtas_call(display_character, 1, 1, NULL, '\r');
-                                rtas_call(display_character, 1, 1, NULL, '\n');
-                        } else {
-                                /* CR might be used to re-draw a line, so we'll
-                                 * leave it alone and not add LF.
-                                 */
-                                rtas_call(display_character, 1, 1, NULL, *os);
-                        }
- 
-                        width = max_width;
-                } else {
-                        width--;
-                        rtas_call(display_character, 1, 1, NULL, *os);
-                }
- 
-                os++;
- 
-                /* if we overwrite the screen length */
-                if (width <= 0)
-                        while ((*os != 0) && (*os != '\n') && (*os != '\r'))
-                                os++;
-        }
- 
-        /* Blank to end of line. */
-        while (width-- > 0)
-                rtas_call(display_character, 1, 1, NULL, ' ');
-
-        spin_unlock(&progress_lock);
-}
-
-extern void setup_default_decr(void);
-
-/* Some sane defaults: 125 MHz timebase, 1GHz processor */
-#define DEFAULT_TB_FREQ         125000000UL
-#define DEFAULT_PROC_FREQ       (DEFAULT_TB_FREQ * 8)
-
-static void __init pSeries_calibrate_decr(void)
-{
-        struct device_node *cpu;
-        struct div_result divres;
-        unsigned int *fp;
-        int node_found;
-
-        /*
-         * The cpu node should have a timebase-frequency property
-         * to tell us the rate at which the decrementer counts.
-         */
-        cpu = of_find_node_by_type(NULL, "cpu");
-
-        ppc_tb_freq = DEFAULT_TB_FREQ;          /* hardcoded default */
-        node_found = 0;
-        if (cpu != 0) {
-                fp = (unsigned int *)get_property(cpu, "timebase-frequency",
-                                                  NULL);
-                if (fp != 0) {
-                        node_found = 1;
-                        ppc_tb_freq = *fp;
-                }
-        }
-        if (!node_found)
-                printk(KERN_ERR "WARNING: Estimating decrementer frequency "
-                                "(not found)\n");
-
-        ppc_proc_freq = DEFAULT_PROC_FREQ;
-        node_found = 0;
-        if (cpu != 0) {
-                fp = (unsigned int *)get_property(cpu, "clock-frequency",
-                                                  NULL);
-                if (fp != 0) {
-                        node_found = 1;
-                        ppc_proc_freq = *fp;
-                }
-        }
-        if (!node_found)
-                printk(KERN_ERR "WARNING: Estimating processor frequency "
-                                "(not found)\n");
-
-        of_node_put(cpu);
-
-        printk(KERN_INFO "time_init: decrementer frequency = %lu.%.6lu MHz\n",
-               ppc_tb_freq/1000000, ppc_tb_freq%1000000);
-        printk(KERN_INFO "time_init: processor frequency   = %lu.%.6lu MHz\n",
-               ppc_proc_freq/1000000, ppc_proc_freq%1000000);
-
-        tb_ticks_per_jiffy = ppc_tb_freq / HZ;
-        tb_ticks_per_sec = tb_ticks_per_jiffy * HZ;
-        tb_ticks_per_usec = ppc_tb_freq / 1000000;
-        tb_to_us = mulhwu_scale_factor(ppc_tb_freq, 1000000);
-        div128_by_32(1024*1024, 0, tb_ticks_per_sec, &divres);
-        tb_to_xs = divres.result_low;
-
-        setup_default_decr();
-}
-
 static int pSeries_check_legacy_ioport(unsigned int baseport)
 {
         struct device_node *np;
@@ -596,16 +425,17 @@ struct machdep_calls __initdata pSeries_md = {
         .get_cpuinfo            = pSeries_get_cpuinfo,
         .log_error              = pSeries_log_error,
         .pcibios_fixup          = pSeries_final_fixup,
+        .irq_bus_setup          = pSeries_irq_bus_setup,
         .restart                = rtas_restart,
         .power_off              = rtas_power_off,
         .halt                   = rtas_halt,
         .panic                  = rtas_os_term,
         .cpu_die                = pSeries_mach_cpu_die,
-        .get_boot_time          = pSeries_get_boot_time,
-        .get_rtc_time           = pSeries_get_rtc_time,
-        .set_rtc_time           = pSeries_set_rtc_time,
-        .calibrate_decr         = pSeries_calibrate_decr,
-        .progress               = pSeries_progress,
+        .get_boot_time          = rtas_get_boot_time,
+        .get_rtc_time           = rtas_get_rtc_time,
+        .set_rtc_time           = rtas_set_rtc_time,
+        .calibrate_decr         = generic_calibrate_decr,
+        .progress               = rtas_progress,
         .check_legacy_ioport    = pSeries_check_legacy_ioport,
         .system_reset_exception = pSeries_system_reset_exception,
         .machine_check_exception = pSeries_machine_check_exception,
diff --git a/arch/ppc64/kernel/pSeries_smp.c b/arch/ppc64/kernel/pSeries_smp.c
index fbad349ec58c..62c55a123560 100644
--- a/arch/ppc64/kernel/pSeries_smp.c
+++ b/arch/ppc64/kernel/pSeries_smp.c
@@ -1,5 +1,5 @@
 /*
- * SMP support for pSeries machines.
+ * SMP support for pSeries and BPA machines.
  *
  * Dave Engebretsen, Peter Bergner, and
  * Mike Corrigan {engebret|bergner|mikec}@us.ibm.com
@@ -47,6 +47,7 @@
 #include <asm/pSeries_reconfig.h>
 
 #include "mpic.h"
+#include "bpa_iic.h"
 
 #ifdef DEBUG
 #define DBG(fmt...) udbg_printf(fmt)
@@ -92,10 +93,13 @@ static int query_cpu_stopped(unsigned int pcpu)
 
 int pSeries_cpu_disable(void)
 {
+        int cpu = smp_processor_id();
+
+        cpu_clear(cpu, cpu_online_map);
         systemcfg->processorCount--;
 
         /*fix boot_cpuid here*/
-        if (smp_processor_id() == boot_cpuid)
+        if (cpu == boot_cpuid)
                 boot_cpuid = any_online_cpu(cpu_online_map);
 
         /* FIXME: abstract this to not be platform specific later on */
@@ -286,6 +290,7 @@ static inline int __devinit smp_startup_cpu(unsigned int lcpu)
         return 1;
 }
 
+#ifdef CONFIG_XICS
 static inline void smp_xics_do_message(int cpu, int msg)
 {
         set_bit(msg, &xics_ipi_message[cpu].value);
@@ -327,6 +332,37 @@ static void __devinit smp_xics_setup_cpu(int cpu)
         cpu_clear(cpu, of_spin_map);
 
 }
+#endif /* CONFIG_XICS */
+#ifdef CONFIG_BPA_IIC
+static void smp_iic_message_pass(int target, int msg)
+{
+        unsigned int i;
+
+        if (target < NR_CPUS) {
+                iic_cause_IPI(target, msg);
+        } else {
+                for_each_online_cpu(i) {
+                        if (target == MSG_ALL_BUT_SELF
+                            && i == smp_processor_id())
+                                continue;
+                        iic_cause_IPI(i, msg);
+                }
+        }
+}
+
+static int __init smp_iic_probe(void)
+{
+        iic_request_IPIs();
+
+        return cpus_weight(cpu_possible_map);
+}
+
+static void __devinit smp_iic_setup_cpu(int cpu)
+{
+        if (cpu != boot_cpuid)
+                iic_setup_cpu();
+}
+#endif /* CONFIG_BPA_IIC */
 
 static DEFINE_SPINLOCK(timebase_lock);
 static unsigned long timebase = 0;
@@ -375,20 +411,21 @@ static int smp_pSeries_cpu_bootable(unsigned int nr)
          * cpus are assumed to be secondary threads.
          */
         if (system_state < SYSTEM_RUNNING &&
-            cur_cpu_spec->cpu_features & CPU_FTR_SMT &&
+            cpu_has_feature(CPU_FTR_SMT) &&
             !smt_enabled_at_boot && nr % 2 != 0)
                 return 0;
 
         return 1;
 }
-
+#ifdef CONFIG_MPIC
 static struct smp_ops_t pSeries_mpic_smp_ops = {
         .message_pass   = smp_mpic_message_pass,
         .probe          = smp_mpic_probe,
         .kick_cpu       = smp_pSeries_kick_cpu,
         .setup_cpu      = smp_mpic_setup_cpu,
 };
-
+#endif
+#ifdef CONFIG_XICS
 static struct smp_ops_t pSeries_xics_smp_ops = {
         .message_pass   = smp_xics_message_pass,
         .probe          = smp_xics_probe,
@@ -396,6 +433,16 @@ static struct smp_ops_t pSeries_xics_smp_ops = {
         .setup_cpu      = smp_xics_setup_cpu,
         .cpu_bootable   = smp_pSeries_cpu_bootable,
 };
+#endif
+#ifdef CONFIG_BPA_IIC
+static struct smp_ops_t bpa_iic_smp_ops = {
+        .message_pass   = smp_iic_message_pass,
+        .probe          = smp_iic_probe,
+        .kick_cpu       = smp_pSeries_kick_cpu,
+        .setup_cpu      = smp_iic_setup_cpu,
+        .cpu_bootable   = smp_pSeries_cpu_bootable,
+};
+#endif
 
 /* This is called very early */
 void __init smp_init_pSeries(void)
@@ -404,10 +451,25 @@ void __init smp_init_pSeries(void)
 
         DBG(" -> smp_init_pSeries()\n");
 
-        if (ppc64_interrupt_controller == IC_OPEN_PIC)
+        switch (ppc64_interrupt_controller) {
+#ifdef CONFIG_MPIC
+        case IC_OPEN_PIC:
                 smp_ops = &pSeries_mpic_smp_ops;
-        else
+                break;
+#endif
+#ifdef CONFIG_XICS
+        case IC_PPC_XIC:
                 smp_ops = &pSeries_xics_smp_ops;
+                break;
+#endif
+#ifdef CONFIG_BPA_IIC
+        case IC_BPA_IIC:
+                smp_ops = &bpa_iic_smp_ops;
+                break;
+#endif
+        default:
+                panic("Invalid interrupt controller");
+        }
 
 #ifdef CONFIG_HOTPLUG_CPU
         smp_ops->cpu_disable = pSeries_cpu_disable;
@@ -419,8 +481,8 @@ void __init smp_init_pSeries(void)
 #endif
 
         /* Mark threads which are still spinning in hold loops. */
-        if (cur_cpu_spec->cpu_features & CPU_FTR_SMT)
-                for_each_present_cpu(i) {
+        if (cpu_has_feature(CPU_FTR_SMT)) {
+                for_each_present_cpu(i) { 
                         if (i % 2 == 0)
                                 /*
                                  * Even-numbered logical cpus correspond to
@@ -428,8 +490,9 @@ void __init smp_init_pSeries(void)
                                  */
                                 cpu_set(i, of_spin_map);
                 }
-        else
+        } else {
                 of_spin_map = cpu_present_map;
+        }
 
         cpu_clear(boot_cpuid, of_spin_map);
 
diff --git a/arch/ppc64/kernel/pacaData.c b/arch/ppc64/kernel/pacaData.c
index a3e0975c26c1..6316188737b6 100644
--- a/arch/ppc64/kernel/pacaData.c
+++ b/arch/ppc64/kernel/pacaData.c
@@ -42,21 +42,7 @@ extern unsigned long __toc_start;
  * processors.  The processor VPD array needs one entry per physical
  * processor (not thread).
  */
-#ifdef CONFIG_PPC_ISERIES
-#define EXTRA_INITS(number, lpq)                                            \
-        .lppaca_ptr = &paca[number].lppaca,                                 \
-        .lpqueue_ptr = (lpq),           /* &xItLpQueue, */                  \
-        .reg_save_ptr = &paca[number].reg_save,                             \
-        .reg_save = {                                                       \
-                .xDesc = 0xd397d9e2,    /* "LpRS" */                        \
-                .xSize = sizeof(struct ItLpRegSave)                         \
-        },
-#else
-#define EXTRA_INITS(number, lpq)
-#endif
-
-#define PACAINITDATA(number,start,lpq,asrr,asrv)                            \
-{                                                                           \
+#define PACA_INIT_COMMON(number, start, asrr, asrv)                         \
         .lock_token = 0x8000,                                               \
         .paca_index = (number),         /* Paca Index */                    \
         .default_decr = 0x00ff0000,     /* Initial Decr */                  \
@@ -74,147 +60,79 @@ extern unsigned long __toc_start;
                 .end_of_quantum = 0xfffffffffffffffful,                     \
                 .slb_count = 64,                                            \
         },                                                                  \
-        EXTRA_INITS((number), (lpq))                                        \
-}
 
-struct paca_struct paca[] = {
 #ifdef CONFIG_PPC_ISERIES
-        PACAINITDATA( 0, 1, &xItLpQueue, 0, STAB0_VIRT_ADDR),
+#define PACA_INIT_ISERIES(number)                                           \
+        .lppaca_ptr = &paca[number].lppaca,                                 \
+        .reg_save_ptr = &paca[number].reg_save,                             \
+        .reg_save = {                                                       \
+                .xDesc = 0xd397d9e2,    /* "LpRS" */                        \
+                .xSize = sizeof(struct ItLpRegSave)                         \
+        }
+
+#define PACA_INIT(number)                                                   \
+{                                                                           \
+        PACA_INIT_COMMON(number, 0, 0, 0)                                   \
+        PACA_INIT_ISERIES(number)                                           \
+}
+
+#define BOOTCPU_PACA_INIT(number)                                           \
+{                                                                           \
+        PACA_INIT_COMMON(number, 1, 0, STAB0_VIRT_ADDR)                     \
+        PACA_INIT_ISERIES(number)                                           \
+}
+
 #else
-        PACAINITDATA( 0, 1, NULL, STAB0_PHYS_ADDR, STAB0_VIRT_ADDR),
+#define PACA_INIT(number)                                                   \
+{                                                                           \
+        PACA_INIT_COMMON(number, 0, 0, 0)                                   \
+}
+
+#define BOOTCPU_PACA_INIT(number)                                           \
+{                                                                           \
+        PACA_INIT_COMMON(number, 1, STAB0_PHYS_ADDR, STAB0_VIRT_ADDR)       \
+}
 #endif
+
+struct paca_struct paca[] = {
+        BOOTCPU_PACA_INIT(0),
 #if NR_CPUS > 1
-        PACAINITDATA( 1, 0, NULL, 0, 0),
-        PACAINITDATA( 2, 0, NULL, 0, 0),
-        PACAINITDATA( 3, 0, NULL, 0, 0),
+        PACA_INIT(  1), PACA_INIT(  2), PACA_INIT(  3),
 #if NR_CPUS > 4
-        PACAINITDATA( 4, 0, NULL, 0, 0),
-        PACAINITDATA( 5, 0, NULL, 0, 0),
-        PACAINITDATA( 6, 0, NULL, 0, 0),
-        PACAINITDATA( 7, 0, NULL, 0, 0),
+        PACA_INIT(  4), PACA_INIT(  5), PACA_INIT(  6), PACA_INIT(  7),
 #if NR_CPUS > 8
-        PACAINITDATA( 8, 0, NULL, 0, 0),
-        PACAINITDATA( 9, 0, NULL, 0, 0),
-        PACAINITDATA(10, 0, NULL, 0, 0),
-        PACAINITDATA(11, 0, NULL, 0, 0),
-        PACAINITDATA(12, 0, NULL, 0, 0),
-        PACAINITDATA(13, 0, NULL, 0, 0),
-        PACAINITDATA(14, 0, NULL, 0, 0),
-        PACAINITDATA(15, 0, NULL, 0, 0),
-        PACAINITDATA(16, 0, NULL, 0, 0),
-        PACAINITDATA(17, 0, NULL, 0, 0),
-        PACAINITDATA(18, 0, NULL, 0, 0),
-        PACAINITDATA(19, 0, NULL, 0, 0),
-        PACAINITDATA(20, 0, NULL, 0, 0),
-        PACAINITDATA(21, 0, NULL, 0, 0),
-        PACAINITDATA(22, 0, NULL, 0, 0),
-        PACAINITDATA(23, 0, NULL, 0, 0),
-        PACAINITDATA(24, 0, NULL, 0, 0),
-        PACAINITDATA(25, 0, NULL, 0, 0),
-        PACAINITDATA(26, 0, NULL, 0, 0),
-        PACAINITDATA(27, 0, NULL, 0, 0),
-        PACAINITDATA(28, 0, NULL, 0, 0),
-        PACAINITDATA(29, 0, NULL, 0, 0),
-        PACAINITDATA(30, 0, NULL, 0, 0),
-        PACAINITDATA(31, 0, NULL, 0, 0),
+        PACA_INIT(  8), PACA_INIT(  9), PACA_INIT( 10), PACA_INIT( 11),
+        PACA_INIT( 12), PACA_INIT( 13), PACA_INIT( 14), PACA_INIT( 15),
+        PACA_INIT( 16), PACA_INIT( 17), PACA_INIT( 18), PACA_INIT( 19),
+        PACA_INIT( 20), PACA_INIT( 21), PACA_INIT( 22), PACA_INIT( 23),
+        PACA_INIT( 24), PACA_INIT( 25), PACA_INIT( 26), PACA_INIT( 27),
+        PACA_INIT( 28), PACA_INIT( 29), PACA_INIT( 30), PACA_INIT( 31),
 #if NR_CPUS > 32
-        PACAINITDATA(32, 0, NULL, 0, 0),
-        PACAINITDATA(33, 0, NULL, 0, 0),
-        PACAINITDATA(34, 0, NULL, 0, 0),
-        PACAINITDATA(35, 0, NULL, 0, 0),
-        PACAINITDATA(36, 0, NULL, 0, 0),
-        PACAINITDATA(37, 0, NULL, 0, 0),
-        PACAINITDATA(38, 0, NULL, 0, 0),
-        PACAINITDATA(39, 0, NULL, 0, 0),
-        PACAINITDATA(40, 0, NULL, 0, 0),
-        PACAINITDATA(41, 0, NULL, 0, 0),
-        PACAINITDATA(42, 0, NULL, 0, 0),
-        PACAINITDATA(43, 0, NULL, 0, 0),
-        PACAINITDATA(44, 0, NULL, 0, 0),
-        PACAINITDATA(45, 0, NULL, 0, 0),
-        PACAINITDATA(46, 0, NULL, 0, 0),
-        PACAINITDATA(47, 0, NULL, 0, 0),
-        PACAINITDATA(48, 0, NULL, 0, 0),
-        PACAINITDATA(49, 0, NULL, 0, 0),
-        PACAINITDATA(50, 0, NULL, 0, 0),
-        PACAINITDATA(51, 0, NULL, 0, 0),
-        PACAINITDATA(52, 0, NULL, 0, 0),
-        PACAINITDATA(53, 0, NULL, 0, 0),
-        PACAINITDATA(54, 0, NULL, 0, 0),
-        PACAINITDATA(55, 0, NULL, 0, 0),
-        PACAINITDATA(56, 0, NULL, 0, 0),
-        PACAINITDATA(57, 0, NULL, 0, 0),
-        PACAINITDATA(58, 0, NULL, 0, 0),
-        PACAINITDATA(59, 0, NULL, 0, 0),
-        PACAINITDATA(60, 0, NULL, 0, 0),
-        PACAINITDATA(61, 0, NULL, 0, 0),
-        PACAINITDATA(62, 0, NULL, 0, 0),
-        PACAINITDATA(63, 0, NULL, 0, 0),
+        PACA_INIT( 32), PACA_INIT( 33), PACA_INIT( 34), PACA_INIT( 35),
+        PACA_INIT( 36), PACA_INIT( 37), PACA_INIT( 38), PACA_INIT( 39),
+        PACA_INIT( 40), PACA_INIT( 41), PACA_INIT( 42), PACA_INIT( 43),
+        PACA_INIT( 44), PACA_INIT( 45), PACA_INIT( 46), PACA_INIT( 47),
+        PACA_INIT( 48), PACA_INIT( 49), PACA_INIT( 50), PACA_INIT( 51),
+        PACA_INIT( 52), PACA_INIT( 53), PACA_INIT( 54), PACA_INIT( 55),
+        PACA_INIT( 56), PACA_INIT( 57), PACA_INIT( 58), PACA_INIT( 59),
+        PACA_INIT( 60), PACA_INIT( 61), PACA_INIT( 62), PACA_INIT( 63),
 #if NR_CPUS > 64
-        PACAINITDATA(64, 0, NULL, 0, 0),
-        PACAINITDATA(65, 0, NULL, 0, 0),
-        PACAINITDATA(66, 0, NULL, 0, 0),
-        PACAINITDATA(67, 0, NULL, 0, 0),
-        PACAINITDATA(68, 0, NULL, 0, 0),
-        PACAINITDATA(69, 0, NULL, 0, 0),
-        PACAINITDATA(70, 0, NULL, 0, 0),
-        PACAINITDATA(71, 0, NULL, 0, 0),
-        PACAINITDATA(72, 0, NULL, 0, 0),
-        PACAINITDATA(73, 0, NULL, 0, 0),
-        PACAINITDATA(74, 0, NULL, 0, 0),
-        PACAINITDATA(75, 0, NULL, 0, 0),
-        PACAINITDATA(76, 0, NULL, 0, 0),
-        PACAINITDATA(77, 0, NULL, 0, 0),
-        PACAINITDATA(78, 0, NULL, 0, 0),
-        PACAINITDATA(79, 0, NULL, 0, 0),
-        PACAINITDATA(80, 0, NULL, 0, 0),
-        PACAINITDATA(81, 0, NULL, 0, 0),
-        PACAINITDATA(82, 0, NULL, 0, 0),
-        PACAINITDATA(83, 0, NULL, 0, 0),
-        PACAINITDATA(84, 0, NULL, 0, 0),
-        PACAINITDATA(85, 0, NULL, 0, 0),
-        PACAINITDATA(86, 0, NULL, 0, 0),
-        PACAINITDATA(87, 0, NULL, 0, 0),
-        PACAINITDATA(88, 0, NULL, 0, 0),
-        PACAINITDATA(89, 0, NULL, 0, 0),
-        PACAINITDATA(90, 0, NULL, 0, 0),
-        PACAINITDATA(91, 0, NULL, 0, 0),
-        PACAINITDATA(92, 0, NULL, 0, 0),
-        PACAINITDATA(93, 0, NULL, 0, 0),
-        PACAINITDATA(94, 0, NULL, 0, 0),
-        PACAINITDATA(95, 0, NULL, 0, 0),
-        PACAINITDATA(96, 0, NULL, 0, 0),
-        PACAINITDATA(97, 0, NULL, 0, 0),
-        PACAINITDATA(98, 0, NULL, 0, 0),
-        PACAINITDATA(99, 0, NULL, 0, 0),
-        PACAINITDATA(100, 0, NULL, 0, 0),
-        PACAINITDATA(101, 0, NULL, 0, 0),
-        PACAINITDATA(102, 0, NULL, 0, 0),
-        PACAINITDATA(103, 0, NULL, 0, 0),
-        PACAINITDATA(104, 0, NULL, 0, 0),
-        PACAINITDATA(105, 0, NULL, 0, 0),
-        PACAINITDATA(106, 0, NULL, 0, 0),
-        PACAINITDATA(107, 0, NULL, 0, 0),
-        PACAINITDATA(108, 0, NULL, 0, 0),
-        PACAINITDATA(109, 0, NULL, 0, 0),
-        PACAINITDATA(110, 0, NULL, 0, 0),
-        PACAINITDATA(111, 0, NULL, 0, 0),
-        PACAINITDATA(112, 0, NULL, 0, 0),
-        PACAINITDATA(113, 0, NULL, 0, 0),
-        PACAINITDATA(114, 0, NULL, 0, 0),
-        PACAINITDATA(115, 0, NULL, 0, 0),
-        PACAINITDATA(116, 0, NULL, 0, 0),
-        PACAINITDATA(117, 0, NULL, 0, 0),
-        PACAINITDATA(118, 0, NULL, 0, 0),
-        PACAINITDATA(119, 0, NULL, 0, 0),
-        PACAINITDATA(120, 0, NULL, 0, 0),
-        PACAINITDATA(121, 0, NULL, 0, 0),
-        PACAINITDATA(122, 0, NULL, 0, 0),
-        PACAINITDATA(123, 0, NULL, 0, 0),
-        PACAINITDATA(124, 0, NULL, 0, 0),
-        PACAINITDATA(125, 0, NULL, 0, 0),
-        PACAINITDATA(126, 0, NULL, 0, 0),
-        PACAINITDATA(127, 0, NULL, 0, 0),
+        PACA_INIT( 64), PACA_INIT( 65), PACA_INIT( 66), PACA_INIT( 67),
+        PACA_INIT( 68), PACA_INIT( 69), PACA_INIT( 70), PACA_INIT( 71),
+        PACA_INIT( 72), PACA_INIT( 73), PACA_INIT( 74), PACA_INIT( 75),
+        PACA_INIT( 76), PACA_INIT( 77), PACA_INIT( 78), PACA_INIT( 79),
+        PACA_INIT( 80), PACA_INIT( 81), PACA_INIT( 82), PACA_INIT( 83),
+        PACA_INIT( 84), PACA_INIT( 85), PACA_INIT( 86), PACA_INIT( 87),
+        PACA_INIT( 88), PACA_INIT( 89), PACA_INIT( 90), PACA_INIT( 91),
+        PACA_INIT( 92), PACA_INIT( 93), PACA_INIT( 94), PACA_INIT( 95),
+        PACA_INIT( 96), PACA_INIT( 97), PACA_INIT( 98), PACA_INIT( 99),
+        PACA_INIT(100), PACA_INIT(101), PACA_INIT(102), PACA_INIT(103),
+        PACA_INIT(104), PACA_INIT(105), PACA_INIT(106), PACA_INIT(107),
+        PACA_INIT(108), PACA_INIT(109), PACA_INIT(110), PACA_INIT(111),
+        PACA_INIT(112), PACA_INIT(113), PACA_INIT(114), PACA_INIT(115),
+        PACA_INIT(116), PACA_INIT(117), PACA_INIT(118), PACA_INIT(119),
+        PACA_INIT(120), PACA_INIT(121), PACA_INIT(122), PACA_INIT(123),
+        PACA_INIT(124), PACA_INIT(125), PACA_INIT(126), PACA_INIT(127),
 #endif
 #endif
 #endif
diff --git a/arch/ppc64/kernel/pci.c b/arch/ppc64/kernel/pci.c
index d786d4b6af0b..ae6f579d3fa0 100644
--- a/arch/ppc64/kernel/pci.c
+++ b/arch/ppc64/kernel/pci.c
@@ -351,7 +351,7 @@ static struct resource *__pci_mmap_make_offset(struct pci_dev *dev,
                 *offset += hose->pci_mem_offset;
                 res_bit = IORESOURCE_MEM;
         } else {
-                io_offset = (unsigned long)hose->io_base_virt;
+                io_offset = (unsigned long)hose->io_base_virt - pci_io_base;
                 *offset += io_offset;
                 res_bit = IORESOURCE_IO;
         }
@@ -378,7 +378,7 @@ static struct resource *__pci_mmap_make_offset(struct pci_dev *dev,
 
                 /* found it! construct the final physical address */
                 if (mmap_state == pci_mmap_io)
-                        *offset += hose->io_base_phys - io_offset;
+                        *offset += hose->io_base_phys - io_offset;
                 return rp;
         }
 
@@ -507,7 +507,7 @@ int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
 }
 
 #ifdef CONFIG_PPC_MULTIPLATFORM
-static ssize_t pci_show_devspec(struct device *dev, char *buf)
+static ssize_t pci_show_devspec(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct pci_dev *pdev;
         struct device_node *np;
@@ -902,6 +902,9 @@ void __devinit pcibios_fixup_bus(struct pci_bus *bus)
         list_for_each_entry(dev, &bus->devices, bus_list)
                 ppc_md.iommu_dev_setup(dev);
 
+        if (ppc_md.irq_bus_setup)
+                ppc_md.irq_bus_setup(bus);
+
         if (!pci_probe_only)
                 return;
 
@@ -941,4 +944,22 @@ int pci_read_irq_line(struct pci_dev *pci_dev)
 }
 EXPORT_SYMBOL(pci_read_irq_line);
 
+void pci_resource_to_user(const struct pci_dev *dev, int bar,
+                          const struct resource *rsrc,
+                          u64 *start, u64 *end)
+{
+        struct pci_controller *hose = pci_bus_to_host(dev->bus);
+        unsigned long offset = 0;
+
+        if (hose == NULL)
+                return;
+
+        if (rsrc->flags & IORESOURCE_IO)
+                offset = pci_io_base - (unsigned long)hose->io_base_virt +
+                        hose->io_base_phys;
+
+        *start = rsrc->start + offset;
+        *end = rsrc->end + offset;
+}
+
 #endif /* CONFIG_PPC_MULTIPLATFORM */
diff --git a/arch/ppc64/kernel/pci.h b/arch/ppc64/kernel/pci.h
index 0fd7d849aa77..26be78b13af1 100644
--- a/arch/ppc64/kernel/pci.h
+++ b/arch/ppc64/kernel/pci.h
@@ -40,10 +40,14 @@ struct device_node *fetch_dev_dn(struct pci_dev *dev);
 void pci_addr_cache_insert_device(struct pci_dev *dev);
 void pci_addr_cache_remove_device(struct pci_dev *dev);
 
-/* From pSeries_pci.h */
+/* From rtas_pci.h */
 void init_pci_config_tokens (void);
 unsigned long get_phb_buid (struct device_node *);
 
+/* From pSeries_pci.h */
+extern void pSeries_final_fixup(void);
+extern void pSeries_irq_bus_setup(struct pci_bus *bus);
+
 extern unsigned long pci_probe_only;
 extern unsigned long pci_assign_all_buses;
 extern int pci_read_irq_line(struct pci_dev *pci_dev);
diff --git a/arch/ppc64/kernel/pmac_time.c b/arch/ppc64/kernel/pmac_time.c
index f24827581dd7..3059edb09cc8 100644
--- a/arch/ppc64/kernel/pmac_time.c
+++ b/arch/ppc64/kernel/pmac_time.c
@@ -40,11 +40,6 @@
 #define DBG(x...)
 #endif
 
-extern void setup_default_decr(void);
-
-extern unsigned long ppc_tb_freq;
-extern unsigned long ppc_proc_freq;
-
 /* Apparently the RTC stores seconds since 1 Jan 1904 */
 #define RTC_OFFSET      2082844800
 
@@ -161,8 +156,7 @@ void __init pmac_get_boot_time(struct rtc_time *tm)
 
 /*
  * Query the OF and get the decr frequency.
- * This was taken from the pmac time_init() when merging the prep/pmac
- * time functions.
+ * FIXME: merge this with generic_calibrate_decr
  */
 void __init pmac_calibrate_decr(void)
 {
diff --git a/arch/ppc64/kernel/ppc_ksyms.c b/arch/ppc64/kernel/ppc_ksyms.c
index b230a63fe4c8..705742f4eec6 100644
--- a/arch/ppc64/kernel/ppc_ksyms.c
+++ b/arch/ppc64/kernel/ppc_ksyms.c
@@ -75,6 +75,7 @@ EXPORT_SYMBOL(giveup_fpu);
 EXPORT_SYMBOL(giveup_altivec);
 #endif
 EXPORT_SYMBOL(__flush_icache_range);
+EXPORT_SYMBOL(flush_dcache_range);
 
 #ifdef CONFIG_SMP
 #ifdef CONFIG_PPC_ISERIES
diff --git a/arch/ppc64/kernel/proc_ppc64.c b/arch/ppc64/kernel/proc_ppc64.c
index 0914b0669b05..a87c66a9652a 100644
--- a/arch/ppc64/kernel/proc_ppc64.c
+++ b/arch/ppc64/kernel/proc_ppc64.c
@@ -53,7 +53,7 @@ static int __init proc_ppc64_create(void)
         if (!root)
                 return 1;
 
-        if (!(systemcfg->platform & PLATFORM_PSERIES))
+        if (!(systemcfg->platform & (PLATFORM_PSERIES | PLATFORM_BPA)))
                 return 0;
 
         if (!proc_mkdir("rtas", root))
diff --git a/arch/ppc64/kernel/process.c b/arch/ppc64/kernel/process.c
index cdfecbeb331f..f7cae05e40fb 100644
--- a/arch/ppc64/kernel/process.c
+++ b/arch/ppc64/kernel/process.c
@@ -36,6 +36,7 @@
 #include <linux/kallsyms.h>
 #include <linux/interrupt.h>
 #include <linux/utsname.h>
+#include <linux/kprobes.h>
 
 #include <asm/pgtable.h>
 #include <asm/uaccess.h>
@@ -58,14 +59,6 @@ struct task_struct *last_task_used_math = NULL;
 struct task_struct *last_task_used_altivec = NULL;
 #endif
 
-struct mm_struct ioremap_mm = {
-        .pgd            = ioremap_dir,
-        .mm_users       = ATOMIC_INIT(2),
-        .mm_count       = ATOMIC_INIT(1),
-        .cpu_vm_mask    = CPU_MASK_ALL,
-        .page_table_lock = SPIN_LOCK_UNLOCKED,
-};
-
 /*
  * Make sure the floating-point register state in the
  * the thread_struct is up to date for task tsk.
@@ -315,6 +308,8 @@ void show_regs(struct pt_regs * regs)
 
 void exit_thread(void)
 {
+        kprobe_flush_task(current);
+
 #ifndef CONFIG_SMP
         if (last_task_used_math == current)
                 last_task_used_math = NULL;
@@ -329,6 +324,7 @@ void flush_thread(void)
 {
         struct thread_info *t = current_thread_info();
 
+        kprobe_flush_task(current);
         if (t->flags & _TIF_ABI_PENDING)
                 t->flags ^= (_TIF_ABI_PENDING | _TIF_32BIT);
 
diff --git a/arch/ppc64/kernel/prom.c b/arch/ppc64/kernel/prom.c
index eb6538b58008..47727a6f7346 100644
--- a/arch/ppc64/kernel/prom.c
+++ b/arch/ppc64/kernel/prom.c
@@ -884,6 +884,7 @@ static int __init early_init_dt_scan_cpus(unsigned long node,
 {
         char *type = get_flat_dt_prop(node, "device_type", NULL);
         u32 *prop;
+        unsigned long size;
 
         /* We are scanning "cpu" nodes only */
         if (type == NULL || strcmp(type, "cpu") != 0)
@@ -929,6 +930,17 @@ static int __init early_init_dt_scan_cpus(unsigned long node,
                 cur_cpu_spec->cpu_user_features |= PPC_FEATURE_HAS_ALTIVEC;
         }
 
+        /*
+         * Check for an SMT capable CPU and set the CPU feature. We do
+         * this by looking at the size of the ibm,ppc-interrupt-server#s
+         * property
+         */
+        prop = (u32 *)get_flat_dt_prop(node, "ibm,ppc-interrupt-server#s",
+                                       &size);
+        cur_cpu_spec->cpu_features &= ~CPU_FTR_SMT;
+        if (prop && ((size / sizeof(u32)) > 1))
+                cur_cpu_spec->cpu_features |= CPU_FTR_SMT;
+
         return 0;
 }
 
diff --git a/arch/ppc64/kernel/prom_init.c b/arch/ppc64/kernel/prom_init.c
index b7683abfbe6a..e248a7950aeb 100644
--- a/arch/ppc64/kernel/prom_init.c
+++ b/arch/ppc64/kernel/prom_init.c
@@ -1915,9 +1915,9 @@ unsigned long __init prom_init(unsigned long r3, unsigned long r4, unsigned long
                 prom_send_capabilities();
 
         /*
-         * On pSeries, copy the CPU hold code
+         * On pSeries and BPA, copy the CPU hold code
          */
-        if (RELOC(of_platform) & PLATFORM_PSERIES)
+        if (RELOC(of_platform) & (PLATFORM_PSERIES | PLATFORM_BPA))
                 copy_and_flush(0, KERNELBASE - offset, 0x100, 0);
 
         /*
diff --git a/arch/ppc64/kernel/ptrace.c b/arch/ppc64/kernel/ptrace.c
index 9f8c6087ae56..2993f108d96d 100644
--- a/arch/ppc64/kernel/ptrace.c
+++ b/arch/ppc64/kernel/ptrace.c
@@ -305,6 +305,8 @@ static void do_syscall_trace(void)
 
 void do_syscall_trace_enter(struct pt_regs *regs)
 {
+        secure_computing(regs->gpr[0]);
+
         if (test_thread_flag(TIF_SYSCALL_TRACE)
             && (current->ptrace & PT_PTRACED))
                 do_syscall_trace();
@@ -320,8 +322,6 @@ void do_syscall_trace_enter(struct pt_regs *regs)
 
 void do_syscall_trace_leave(struct pt_regs *regs)
 {
-        secure_computing(regs->gpr[0]);
-
         if (unlikely(current->audit_context))
                 audit_syscall_exit(current, 
                                    (regs->ccr&0x1000)?AUDITSC_FAILURE:AUDITSC_SUCCESS,
diff --git a/arch/ppc64/kernel/ras.c b/arch/ppc64/kernel/ras.c
index 1c4c796b212b..3c00f7bfc1b5 100644
--- a/arch/ppc64/kernel/ras.c
+++ b/arch/ppc64/kernel/ras.c
@@ -47,7 +47,6 @@
 #include <asm/cache.h>
 #include <asm/prom.h>
 #include <asm/ptrace.h>
-#include <asm/iSeries/LparData.h>
 #include <asm/machdep.h>
 #include <asm/rtas.h>
 #include <asm/ppcdebug.h>
diff --git a/arch/ppc64/kernel/rtas-proc.c b/arch/ppc64/kernel/rtas-proc.c
index 28b1f1521f21..1f3ff860fdf0 100644
--- a/arch/ppc64/kernel/rtas-proc.c
+++ b/arch/ppc64/kernel/rtas-proc.c
@@ -371,11 +371,11 @@ static ssize_t ppc_rtas_progress_write(struct file *file,
         /* Lets see if the user passed hexdigits */
         hex = simple_strtoul(progress_led, NULL, 10);
 
-        ppc_md.progress ((char *)progress_led, hex);
+        rtas_progress ((char *)progress_led, hex);
         return count;
 
         /* clear the line */
-        /* ppc_md.progress("                   ", 0xffff);*/
+        /* rtas_progress("                   ", 0xffff);*/
 }
 /* ****************************************************************** */
 static int ppc_rtas_progress_show(struct seq_file *m, void *v)
diff --git a/arch/ppc64/kernel/rtas.c b/arch/ppc64/kernel/rtas.c
index 5575603def27..5e8eb33b8e54 100644
--- a/arch/ppc64/kernel/rtas.c
+++ b/arch/ppc64/kernel/rtas.c
@@ -91,6 +91,123 @@ call_rtas_display_status_delay(unsigned char c)
         }
 }
 
+void
+rtas_progress(char *s, unsigned short hex)
+{
+        struct device_node *root;
+        int width, *p;
+        char *os;
+        static int display_character, set_indicator;
+        static int display_width, display_lines, *row_width, form_feed;
+        static DEFINE_SPINLOCK(progress_lock);
+        static int current_line;
+        static int pending_newline = 0;  /* did last write end with unprinted newline? */
+
+        if (!rtas.base)
+                return;
+
+        if (display_width == 0) {
+                display_width = 0x10;
+                if ((root = find_path_device("/rtas"))) {
+                        if ((p = (unsigned int *)get_property(root,
+                                        "ibm,display-line-length", NULL)))
+                                display_width = *p;
+                        if ((p = (unsigned int *)get_property(root,
+                                        "ibm,form-feed", NULL)))
+                                form_feed = *p;
+                        if ((p = (unsigned int *)get_property(root,
+                                        "ibm,display-number-of-lines", NULL)))
+                                display_lines = *p;
+                        row_width = (unsigned int *)get_property(root,
+                                        "ibm,display-truncation-length", NULL);
+                }
+                display_character = rtas_token("display-character");
+                set_indicator = rtas_token("set-indicator");
+        }
+
+        if (display_character == RTAS_UNKNOWN_SERVICE) {
+                /* use hex display if available */
+                if (set_indicator != RTAS_UNKNOWN_SERVICE)
+                        rtas_call(set_indicator, 3, 1, NULL, 6, 0, hex);
+                return;
+        }
+
+        spin_lock(&progress_lock);
+
+        /*
+         * Last write ended with newline, but we didn't print it since
+         * it would just clear the bottom line of output. Print it now
+         * instead.
+         *
+         * If no newline is pending and form feed is supported, clear the
+         * display with a form feed; otherwise, print a CR to start output
+         * at the beginning of the line.
+         */
+        if (pending_newline) {
+                rtas_call(display_character, 1, 1, NULL, '\r');
+                rtas_call(display_character, 1, 1, NULL, '\n');
+                pending_newline = 0;
+        } else {
+                current_line = 0;
+                if (form_feed)
+                        rtas_call(display_character, 1, 1, NULL,
+                                  (char)form_feed);
+                else
+                        rtas_call(display_character, 1, 1, NULL, '\r');
+        }
+ 
+        if (row_width)
+                width = row_width[current_line];
+        else
+                width = display_width;
+        os = s;
+        while (*os) {
+                if (*os == '\n' || *os == '\r') {
+                        /* If newline is the last character, save it
+                         * until next call to avoid bumping up the
+                         * display output.
+                         */
+                        if (*os == '\n' && !os[1]) {
+                                pending_newline = 1;
+                                current_line++;
+                                if (current_line > display_lines-1)
+                                        current_line = display_lines-1;
+                                spin_unlock(&progress_lock);
+                                return;
+                        }
+ 
+                        /* RTAS wants CR-LF, not just LF */
+ 
+                        if (*os == '\n') {
+                                rtas_call(display_character, 1, 1, NULL, '\r');
+                                rtas_call(display_character, 1, 1, NULL, '\n');
+                        } else {
+                                /* CR might be used to re-draw a line, so we'll
+                                 * leave it alone and not add LF.
+                                 */
+                                rtas_call(display_character, 1, 1, NULL, *os);
+                        }
+ 
+                        if (row_width)
+                                width = row_width[current_line];
+                        else
+                                width = display_width;
+                } else {
+                        width--;
+                        rtas_call(display_character, 1, 1, NULL, *os);
+                }
+ 
+                os++;
+ 
+                /* if we overwrite the screen length */
+                if (width <= 0)
+                        while ((*os != 0) && (*os != '\n') && (*os != '\r'))
+                                os++;
+        }
+ 
+        spin_unlock(&progress_lock);
+}
+
 int
 rtas_token(const char *service)
 {
@@ -425,8 +542,8 @@ rtas_flash_firmware(void)
 
         printk(KERN_ALERT "FLASH: flash image is %ld bytes\n", image_size);
         printk(KERN_ALERT "FLASH: performing flash and reboot\n");
-        ppc_md.progress("Flashing        \n", 0x0);
-        ppc_md.progress("Please Wait...  ", 0x0);
+        rtas_progress("Flashing        \n", 0x0);
+        rtas_progress("Please Wait...  ", 0x0);
         printk(KERN_ALERT "FLASH: this will take several minutes.  Do not power off!\n");
         status = rtas_call(update_token, 1, 1, NULL, rtas_block_list);
         switch (status) {       /* should only get "bad" status */
diff --git a/arch/ppc64/kernel/rtas_pci.c b/arch/ppc64/kernel/rtas_pci.c
new file mode 100644
index 000000000000..1048817befb8
--- /dev/null
+++ b/arch/ppc64/kernel/rtas_pci.c
@@ -0,0 +1,495 @@
+/*
+ * arch/ppc64/kernel/rtas_pci.c
+ *
+ * Copyright (C) 2001 Dave Engebretsen, IBM Corporation
+ * Copyright (C) 2003 Anton Blanchard <anton@au.ibm.com>, IBM
+ *
+ * RTAS specific routines for PCI.
+ * 
+ * Based on code from pci.c, chrp_pci.c and pSeries_pci.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *    
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/threads.h>
+#include <linux/pci.h>
+#include <linux/string.h>
+#include <linux/init.h>
+#include <linux/bootmem.h>
+
+#include <asm/io.h>
+#include <asm/pgtable.h>
+#include <asm/irq.h>
+#include <asm/prom.h>
+#include <asm/machdep.h>
+#include <asm/pci-bridge.h>
+#include <asm/iommu.h>
+#include <asm/rtas.h>
+
+#include "mpic.h"
+#include "pci.h"
+
+/* RTAS tokens */
+static int read_pci_config;
+static int write_pci_config;
+static int ibm_read_pci_config;
+static int ibm_write_pci_config;
+
+static int config_access_valid(struct device_node *dn, int where)
+{
+        if (where < 256)
+                return 1;
+        if (where < 4096 && dn->pci_ext_config_space)
+                return 1;
+
+        return 0;
+}
+
+static int rtas_read_config(struct device_node *dn, int where, int size, u32 *val)
+{
+        int returnval = -1;
+        unsigned long buid, addr;
+        int ret;
+
+        if (!dn)
+                return PCIBIOS_DEVICE_NOT_FOUND;
+        if (!config_access_valid(dn, where))
+                return PCIBIOS_BAD_REGISTER_NUMBER;
+
+        addr = ((where & 0xf00) << 20) | (dn->busno << 16) |
+                (dn->devfn << 8) | (where & 0xff);
+        buid = dn->phb->buid;
+        if (buid) {
+                ret = rtas_call(ibm_read_pci_config, 4, 2, &returnval,
+                                addr, buid >> 32, buid & 0xffffffff, size);
+        } else {
+                ret = rtas_call(read_pci_config, 2, 2, &returnval, addr, size);
+        }
+        *val = returnval;
+
+        if (ret)
+                return PCIBIOS_DEVICE_NOT_FOUND;
+
+        if (returnval == EEH_IO_ERROR_VALUE(size)
+            && eeh_dn_check_failure (dn, NULL))
+                return PCIBIOS_DEVICE_NOT_FOUND;
+
+        return PCIBIOS_SUCCESSFUL;
+}
+
+static int rtas_pci_read_config(struct pci_bus *bus,
+                                unsigned int devfn,
+                                int where, int size, u32 *val)
+{
+        struct device_node *busdn, *dn;
+
+        if (bus->self)
+                busdn = pci_device_to_OF_node(bus->self);
+        else
+                busdn = bus->sysdata;   /* must be a phb */
+
+        /* Search only direct children of the bus */
+        for (dn = busdn->child; dn; dn = dn->sibling)
+                if (dn->devfn == devfn)
+                        return rtas_read_config(dn, where, size, val);
+        return PCIBIOS_DEVICE_NOT_FOUND;
+}
+
+static int rtas_write_config(struct device_node *dn, int where, int size, u32 val)
+{
+        unsigned long buid, addr;
+        int ret;
+
+        if (!dn)
+                return PCIBIOS_DEVICE_NOT_FOUND;
+        if (!config_access_valid(dn, where))
+                return PCIBIOS_BAD_REGISTER_NUMBER;
+
+        addr = ((where & 0xf00) << 20) | (dn->busno << 16) |
+                (dn->devfn << 8) | (where & 0xff);
+        buid = dn->phb->buid;
+        if (buid) {
+                ret = rtas_call(ibm_write_pci_config, 5, 1, NULL, addr, buid >> 32, buid & 0xffffffff, size, (ulong) val);
+        } else {
+                ret = rtas_call(write_pci_config, 3, 1, NULL, addr, size, (ulong)val);
+        }
+
+        if (ret)
+                return PCIBIOS_DEVICE_NOT_FOUND;
+
+        return PCIBIOS_SUCCESSFUL;
+}
+
+static int rtas_pci_write_config(struct pci_bus *bus,
+                                 unsigned int devfn,
+                                 int where, int size, u32 val)
+{
+        struct device_node *busdn, *dn;
+
+        if (bus->self)
+                busdn = pci_device_to_OF_node(bus->self);
+        else
+                busdn = bus->sysdata;   /* must be a phb */
+
+        /* Search only direct children of the bus */
+        for (dn = busdn->child; dn; dn = dn->sibling)
+                if (dn->devfn == devfn)
+                        return rtas_write_config(dn, where, size, val);
+        return PCIBIOS_DEVICE_NOT_FOUND;
+}
+
+struct pci_ops rtas_pci_ops = {
+        rtas_pci_read_config,
+        rtas_pci_write_config
+};
+
+int is_python(struct device_node *dev)
+{
+        char *model = (char *)get_property(dev, "model", NULL);
+
+        if (model && strstr(model, "Python"))
+                return 1;
+
+        return 0;
+}
+
+static int get_phb_reg_prop(struct device_node *dev,
+                            unsigned int addr_size_words,
+                            struct reg_property64 *reg)
+{
+        unsigned int *ui_ptr = NULL, len;
+
+        /* Found a PHB, now figure out where his registers are mapped. */
+        ui_ptr = (unsigned int *)get_property(dev, "reg", &len);
+        if (ui_ptr == NULL)
+                return 1;
+
+        if (addr_size_words == 1) {
+                reg->address = ((struct reg_property32 *)ui_ptr)->address;
+                reg->size    = ((struct reg_property32 *)ui_ptr)->size;
+        } else {
+                *reg = *((struct reg_property64 *)ui_ptr);
+        }
+
+        return 0;
+}
+
+static void python_countermeasures(struct device_node *dev,
+                                   unsigned int addr_size_words)
+{
+        struct reg_property64 reg_struct;
+        void __iomem *chip_regs;
+        volatile u32 val;
+
+        if (get_phb_reg_prop(dev, addr_size_words, &reg_struct))
+                return;
+
+        /* Python's register file is 1 MB in size. */
+        chip_regs = ioremap(reg_struct.address & ~(0xfffffUL), 0x100000);
+
+        /* 
+         * Firmware doesn't always clear this bit which is critical
+         * for good performance - Anton
+         */
+
+#define PRG_CL_RESET_VALID 0x00010000
+
+        val = in_be32(chip_regs + 0xf6030);
+        if (val & PRG_CL_RESET_VALID) {
+                printk(KERN_INFO "Python workaround: ");
+                val &= ~PRG_CL_RESET_VALID;
+                out_be32(chip_regs + 0xf6030, val);
+                /*
+                 * We must read it back for changes to
+                 * take effect
+                 */
+                val = in_be32(chip_regs + 0xf6030);
+                printk("reg0: %x\n", val);
+        }
+
+        iounmap(chip_regs);
+}
+
+void __init init_pci_config_tokens (void)
+{
+        read_pci_config = rtas_token("read-pci-config");
+        write_pci_config = rtas_token("write-pci-config");
+        ibm_read_pci_config = rtas_token("ibm,read-pci-config");
+        ibm_write_pci_config = rtas_token("ibm,write-pci-config");
+}
+
+unsigned long __devinit get_phb_buid (struct device_node *phb)
+{
+        int addr_cells;
+        unsigned int *buid_vals;
+        unsigned int len;
+        unsigned long buid;
+
+        if (ibm_read_pci_config == -1) return 0;
+
+        /* PHB's will always be children of the root node,
+         * or so it is promised by the current firmware. */
+        if (phb->parent == NULL)
+                return 0;
+        if (phb->parent->parent)
+                return 0;
+
+        buid_vals = (unsigned int *) get_property(phb, "reg", &len);
+        if (buid_vals == NULL)
+                return 0;
+
+        addr_cells = prom_n_addr_cells(phb);
+        if (addr_cells == 1) {
+                buid = (unsigned long) buid_vals[0];
+        } else {
+                buid = (((unsigned long)buid_vals[0]) << 32UL) |
+                        (((unsigned long)buid_vals[1]) & 0xffffffff);
+        }
+        return buid;
+}
+
+static int phb_set_bus_ranges(struct device_node *dev,
+                              struct pci_controller *phb)
+{
+        int *bus_range;
+        unsigned int len;
+
+        bus_range = (int *) get_property(dev, "bus-range", &len);
+        if (bus_range == NULL || len < 2 * sizeof(int)) {
+                return 1;
+        }
+ 
+        phb->first_busno =  bus_range[0];
+        phb->last_busno  =  bus_range[1];
+
+        return 0;
+}
+
+static int __devinit setup_phb(struct device_node *dev,
+                               struct pci_controller *phb,
+                               unsigned int addr_size_words)
+{
+        pci_setup_pci_controller(phb);
+
+        if (is_python(dev))
+                python_countermeasures(dev, addr_size_words);
+
+        if (phb_set_bus_ranges(dev, phb))
+                return 1;
+
+        phb->arch_data = dev;
+        phb->ops = &rtas_pci_ops;
+        phb->buid = get_phb_buid(dev);
+
+        return 0;
+}
+
+static void __devinit add_linux_pci_domain(struct device_node *dev,
+                                           struct pci_controller *phb,
+                                           struct property *of_prop)
+{
+        memset(of_prop, 0, sizeof(struct property));
+        of_prop->name = "linux,pci-domain";
+        of_prop->length = sizeof(phb->global_number);
+        of_prop->value = (unsigned char *)&of_prop[1];
+        memcpy(of_prop->value, &phb->global_number, sizeof(phb->global_number));
+        prom_add_property(dev, of_prop);
+}
+
+static struct pci_controller * __init alloc_phb(struct device_node *dev,
+                                                unsigned int addr_size_words)
+{
+        struct pci_controller *phb;
+        struct property *of_prop;
+
+        phb = alloc_bootmem(sizeof(struct pci_controller));
+        if (phb == NULL)
+                return NULL;
+
+        of_prop = alloc_bootmem(sizeof(struct property) +
+                                sizeof(phb->global_number));
+        if (!of_prop)
+                return NULL;
+
+        if (setup_phb(dev, phb, addr_size_words))
+                return NULL;
+
+        add_linux_pci_domain(dev, phb, of_prop);
+
+        return phb;
+}
+
+static struct pci_controller * __devinit alloc_phb_dynamic(struct device_node *dev, unsigned int addr_size_words)
+{
+        struct pci_controller *phb;
+
+        phb = (struct pci_controller *)kmalloc(sizeof(struct pci_controller),
+                                               GFP_KERNEL);
+        if (phb == NULL)
+                return NULL;
+
+        if (setup_phb(dev, phb, addr_size_words))
+                return NULL;
+
+        phb->is_dynamic = 1;
+
+        /* TODO: linux,pci-domain? */
+
+        return phb;
+}
+
+unsigned long __init find_and_init_phbs(void)
+{
+        struct device_node *node;
+        struct pci_controller *phb;
+        unsigned int root_size_cells = 0;
+        unsigned int index;
+        unsigned int *opprop = NULL;
+        struct device_node *root = of_find_node_by_path("/");
+
+        if (ppc64_interrupt_controller == IC_OPEN_PIC) {
+                opprop = (unsigned int *)get_property(root,
+                                "platform-open-pic", NULL);
+        }
+
+        root_size_cells = prom_n_size_cells(root);
+
+        index = 0;
+
+        for (node = of_get_next_child(root, NULL);
+             node != NULL;
+             node = of_get_next_child(root, node)) {
+                if (node->type == NULL || strcmp(node->type, "pci") != 0)
+                        continue;
+
+                phb = alloc_phb(node, root_size_cells);
+                if (!phb)
+                        continue;
+
+                pci_process_bridge_OF_ranges(phb, node);
+                pci_setup_phb_io(phb, index == 0);
+#ifdef CONFIG_PPC_PSERIES
+                if (ppc64_interrupt_controller == IC_OPEN_PIC && pSeries_mpic) {
+                        int addr = root_size_cells * (index + 2) - 1;
+                        mpic_assign_isu(pSeries_mpic, index, opprop[addr]);
+                }
+#endif
+                index++;
+        }
+
+        of_node_put(root);
+        pci_devs_phb_init();
+
+        /*
+         * pci_probe_only and pci_assign_all_buses can be set via properties
+         * in chosen.
+         */
+        if (of_chosen) {
+                int *prop;
+
+                prop = (int *)get_property(of_chosen, "linux,pci-probe-only",
+                                           NULL);
+                if (prop)
+                        pci_probe_only = *prop;
+
+                prop = (int *)get_property(of_chosen,
+                                           "linux,pci-assign-all-buses", NULL);
+                if (prop)
+                        pci_assign_all_buses = *prop;
+        }
+
+        return 0;
+}
+
+struct pci_controller * __devinit init_phb_dynamic(struct device_node *dn)
+{
+        struct device_node *root = of_find_node_by_path("/");
+        unsigned int root_size_cells = 0;
+        struct pci_controller *phb;
+        struct pci_bus *bus;
+        int primary;
+
+        root_size_cells = prom_n_size_cells(root);
+
+        primary = list_empty(&hose_list);
+        phb = alloc_phb_dynamic(dn, root_size_cells);
+        if (!phb)
+                return NULL;
+
+        pci_process_bridge_OF_ranges(phb, dn);
+
+        pci_setup_phb_io_dynamic(phb, primary);
+        of_node_put(root);
+
+        pci_devs_phb_init_dynamic(phb);
+        phb->last_busno = 0xff;
+        bus = pci_scan_bus(phb->first_busno, phb->ops, phb->arch_data);
+        phb->bus = bus;
+        phb->last_busno = bus->subordinate;
+
+        return phb;
+}
+EXPORT_SYMBOL(init_phb_dynamic);
+
+/* RPA-specific bits for removing PHBs */
+int pcibios_remove_root_bus(struct pci_controller *phb)
+{
+        struct pci_bus *b = phb->bus;
+        struct resource *res;
+        int rc, i;
+
+        res = b->resource[0];
+        if (!res->flags) {
+                printk(KERN_ERR "%s: no IO resource for PHB %s\n", __FUNCTION__,
+                                b->name);
+                return 1;
+        }
+
+        rc = unmap_bus_range(b);
+        if (rc) {
+                printk(KERN_ERR "%s: failed to unmap IO on bus %s\n",
+                        __FUNCTION__, b->name);
+                return 1;
+        }
+
+        if (release_resource(res)) {
+                printk(KERN_ERR "%s: failed to release IO on bus %s\n",
+                                __FUNCTION__, b->name);
+                return 1;
+        }
+
+        for (i = 1; i < 3; ++i) {
+                res = b->resource[i];
+                if (!res->flags && i == 0) {
+                        printk(KERN_ERR "%s: no MEM resource for PHB %s\n",
+                                __FUNCTION__, b->name);
+                        return 1;
+                }
+                if (res->flags && release_resource(res)) {
+                        printk(KERN_ERR
+                               "%s: failed to release IO %d on bus %s\n",
+                                __FUNCTION__, i, b->name);
+                        return 1;
+                }
+        }
+
+        list_del(&phb->list_node);
+        if (phb->is_dynamic)
+                kfree(phb);
+
+        return 0;
+}
+EXPORT_SYMBOL(pcibios_remove_root_bus);
diff --git a/arch/ppc64/kernel/rtasd.c b/arch/ppc64/kernel/rtasd.c
index ff65dc33320e..b0c3b829fe47 100644
--- a/arch/ppc64/kernel/rtasd.c
+++ b/arch/ppc64/kernel/rtasd.c
@@ -440,7 +440,7 @@ static int rtasd(void *unused)
                 goto error;
         }
 
-        printk(KERN_ERR "RTAS daemon started\n");
+        printk(KERN_INFO "RTAS daemon started\n");
 
         DEBUG("will sleep for %d jiffies\n", (HZ*60/rtas_event_scan_rate) / 2);
 
@@ -485,7 +485,7 @@ static int __init rtas_init(void)
         /* No RTAS, only warn if we are on a pSeries box  */
         if (rtas_token("event-scan") == RTAS_UNKNOWN_SERVICE) {
                 if (systemcfg->platform & PLATFORM_PSERIES)
-                        printk(KERN_ERR "rtasd: no event-scan on system\n");
+                        printk(KERN_INFO "rtasd: no event-scan on system\n");
                 return 1;
         }
 
diff --git a/arch/ppc64/kernel/rtc.c b/arch/ppc64/kernel/rtc.c
index 67989055a9fe..d729fefa0df5 100644
--- a/arch/ppc64/kernel/rtc.c
+++ b/arch/ppc64/kernel/rtc.c
@@ -42,10 +42,8 @@
 #include <asm/time.h>
 #include <asm/rtas.h>
 
-#include <asm/iSeries/LparData.h>
 #include <asm/iSeries/mf.h>
 #include <asm/machdep.h>
-#include <asm/iSeries/ItSpCommArea.h>
 
 extern int piranha_simulator;
 
@@ -303,7 +301,7 @@ void iSeries_get_boot_time(struct rtc_time *tm)
 #ifdef CONFIG_PPC_RTAS
 #define MAX_RTC_WAIT 5000       /* 5 sec */
 #define RTAS_CLOCK_BUSY (-2)
-void pSeries_get_boot_time(struct rtc_time *rtc_tm)
+void rtas_get_boot_time(struct rtc_time *rtc_tm)
 {
         int ret[8];
         int error, wait_time;
@@ -338,7 +336,7 @@ void pSeries_get_boot_time(struct rtc_time *rtc_tm)
  * and if a delay is needed to read the clock.  In this case we just
  * silently return without updating rtc_tm.
  */
-void pSeries_get_rtc_time(struct rtc_time *rtc_tm)
+void rtas_get_rtc_time(struct rtc_time *rtc_tm)
 {
         int ret[8];
         int error, wait_time;
@@ -373,7 +371,7 @@ void pSeries_get_rtc_time(struct rtc_time *rtc_tm)
         rtc_tm->tm_year = ret[0] - 1900;
 }
 
-int pSeries_set_rtc_time(struct rtc_time *tm)
+int rtas_set_rtc_time(struct rtc_time *tm)
 {
         int error, wait_time;
         unsigned long max_wait_tb;
diff --git a/arch/ppc64/kernel/setup.c b/arch/ppc64/kernel/setup.c
index dce198d39328..d5e4866e9ac2 100644
--- a/arch/ppc64/kernel/setup.c
+++ b/arch/ppc64/kernel/setup.c
@@ -41,7 +41,6 @@
 #include <asm/smp.h>
 #include <asm/elf.h>
 #include <asm/machdep.h>
-#include <asm/iSeries/LparData.h>
 #include <asm/paca.h>
 #include <asm/ppcdebug.h>
 #include <asm/time.h>
@@ -57,6 +56,8 @@
 #include <asm/cache.h>
 #include <asm/page.h>
 #include <asm/mmu.h>
+#include <asm/lmb.h>
+#include <asm/iSeries/ItLpNaca.h>
 
 #ifdef DEBUG
 #define DBG(fmt...) udbg_printf(fmt)
@@ -343,6 +344,7 @@ static void __init setup_cpu_maps(void)
 extern struct machdep_calls pSeries_md;
 extern struct machdep_calls pmac_md;
 extern struct machdep_calls maple_md;
+extern struct machdep_calls bpa_md;
 
 /* Ultimately, stuff them in an elf section like initcalls... */
 static struct machdep_calls __initdata *machines[] = {
@@ -355,6 +357,9 @@ static struct machdep_calls __initdata *machines[] = {
 #ifdef CONFIG_PPC_MAPLE
         &maple_md,
 #endif /* CONFIG_PPC_MAPLE */
+#ifdef CONFIG_PPC_BPA
+        &bpa_md,
+#endif
         NULL
 };
 
@@ -672,37 +677,52 @@ void __init setup_system(void)
         DBG(" <- setup_system()\n");
 }
 
-
-void machine_restart(char *cmd)
+/* also used by kexec */
+void machine_shutdown(void)
 {
         if (ppc_md.nvram_sync)
                 ppc_md.nvram_sync();
-        ppc_md.restart(cmd);
 }
 
+void machine_restart(char *cmd)
+{
+        machine_shutdown();
+        ppc_md.restart(cmd);
+#ifdef CONFIG_SMP
+        smp_send_stop();
+#endif
+        printk(KERN_EMERG "System Halted, OK to turn off power\n");
+        local_irq_disable();
+        while (1) ;
+}
 EXPORT_SYMBOL(machine_restart);
-  
+
 void machine_power_off(void)
 {
-        if (ppc_md.nvram_sync)
-                ppc_md.nvram_sync();
+        machine_shutdown();
         ppc_md.power_off();
+#ifdef CONFIG_SMP
+        smp_send_stop();
+#endif
+        printk(KERN_EMERG "System Halted, OK to turn off power\n");
+        local_irq_disable();
+        while (1) ;
 }
-
 EXPORT_SYMBOL(machine_power_off);
-  
+
 void machine_halt(void)
 {
-        if (ppc_md.nvram_sync)
-                ppc_md.nvram_sync();
+        machine_shutdown();
         ppc_md.halt();
+#ifdef CONFIG_SMP
+        smp_send_stop();
+#endif
+        printk(KERN_EMERG "System Halted, OK to turn off power\n");
+        local_irq_disable();
+        while (1) ;
 }
-
 EXPORT_SYMBOL(machine_halt);
 
-unsigned long ppc_proc_freq;
-unsigned long ppc_tb_freq;
-
 static int ppc64_panic_event(struct notifier_block *this,
                              unsigned long event, void *ptr)
 {
@@ -1054,6 +1074,7 @@ void __init setup_arch(char **cmdline_p)
 
         /* set up the bootmem stuff with available memory */
         do_init_bootmem();
+        sparse_init();
 
         /* initialize the syscall map in systemcfg */
         setup_syscall_map();
@@ -1078,11 +1099,11 @@ void __init setup_arch(char **cmdline_p)
 static void ppc64_do_msg(unsigned int src, const char *msg)
 {
         if (ppc_md.progress) {
-                char buf[32];
+                char buf[128];
 
-                sprintf(buf, "%08x        \n", src);
+                sprintf(buf, "%08X\n", src);
                 ppc_md.progress(buf, 0);
-                sprintf(buf, "%-16s", msg);
+                snprintf(buf, 128, "%s", msg);
                 ppc_md.progress(buf, 0);
         }
 }
@@ -1116,7 +1137,7 @@ void ppc64_dump_msg(unsigned int src, const char *msg)
 }
 
 /* This should only be called on processor 0 during calibrate decr */
-void setup_default_decr(void)
+void __init setup_default_decr(void)
 {
         struct paca_struct *lpaca = get_paca();
 
diff --git a/arch/ppc64/kernel/smp.c b/arch/ppc64/kernel/smp.c
index 9ef5d36d6b25..2fcddfcb594d 100644
--- a/arch/ppc64/kernel/smp.c
+++ b/arch/ppc64/kernel/smp.c
@@ -71,7 +71,7 @@ void smp_call_function_interrupt(void);
 
 int smt_enabled_at_boot = 1;
 
-#ifdef CONFIG_PPC_MULTIPLATFORM
+#ifdef CONFIG_MPIC
 void smp_mpic_message_pass(int target, int msg)
 {
         /* make sure we're sending something that translates to an IPI */
@@ -128,7 +128,7 @@ void __devinit smp_generic_kick_cpu(int nr)
         smp_mb();
 }
 
-#endif /* CONFIG_PPC_MULTIPLATFORM */
+#endif /* CONFIG_MPIC */
 
 static void __init smp_space_timers(unsigned int max_cpus)
 {
diff --git a/arch/ppc64/kernel/spider-pic.c b/arch/ppc64/kernel/spider-pic.c
new file mode 100644
index 000000000000..d5c9a02fb119
--- /dev/null
+++ b/arch/ppc64/kernel/spider-pic.c
@@ -0,0 +1,191 @@
+/*
+ * External Interrupt Controller on Spider South Bridge
+ *
+ * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
+ *
+ * Author: Arnd Bergmann <arndb@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+
+#include <asm/pgtable.h>
+#include <asm/prom.h>
+#include <asm/io.h>
+
+#include "bpa_iic.h"
+
+/* register layout taken from Spider spec, table 7.4-4 */
+enum {
+        TIR_DEN         = 0x004, /* Detection Enable Register */
+        TIR_MSK         = 0x084, /* Mask Level Register */
+        TIR_EDC         = 0x0c0, /* Edge Detection Clear Register */
+        TIR_PNDA        = 0x100, /* Pending Register A */
+        TIR_PNDB        = 0x104, /* Pending Register B */
+        TIR_CS          = 0x144, /* Current Status Register */
+        TIR_LCSA        = 0x150, /* Level Current Status Register A */
+        TIR_LCSB        = 0x154, /* Level Current Status Register B */
+        TIR_LCSC        = 0x158, /* Level Current Status Register C */
+        TIR_LCSD        = 0x15c, /* Level Current Status Register D */
+        TIR_CFGA        = 0x200, /* Setting Register A0 */
+        TIR_CFGB        = 0x204, /* Setting Register B0 */
+                        /* 0x208 ... 0x3ff Setting Register An/Bn */
+        TIR_PPNDA       = 0x400, /* Packet Pending Register A */
+        TIR_PPNDB       = 0x404, /* Packet Pending Register B */
+        TIR_PIERA       = 0x408, /* Packet Output Error Register A */
+        TIR_PIERB       = 0x40c, /* Packet Output Error Register B */
+        TIR_PIEN        = 0x444, /* Packet Output Enable Register */
+        TIR_PIPND       = 0x454, /* Packet Output Pending Register */
+        TIRDID          = 0x484, /* Spider Device ID Register */
+        REISTIM         = 0x500, /* Reissue Command Timeout Time Setting */
+        REISTIMEN       = 0x504, /* Reissue Command Timeout Setting */
+        REISWAITEN      = 0x508, /* Reissue Wait Control*/
+};
+
+static void __iomem *spider_pics[4];
+
+static void __iomem *spider_get_pic(int irq)
+{
+        int node = irq / IIC_NODE_STRIDE;
+        irq %= IIC_NODE_STRIDE;
+
+        if (irq >= IIC_EXT_OFFSET &&
+            irq < IIC_EXT_OFFSET + IIC_NUM_EXT &&
+            spider_pics)
+                return spider_pics[node];
+        return NULL;
+}
+
+static int spider_get_nr(unsigned int irq)
+{
+        return (irq % IIC_NODE_STRIDE) - IIC_EXT_OFFSET;
+}
+
+static void __iomem *spider_get_irq_config(int irq)
+{
+        void __iomem *pic;
+        pic = spider_get_pic(irq);
+        return pic + TIR_CFGA + 8 * spider_get_nr(irq);
+}
+
+static void spider_enable_irq(unsigned int irq)
+{
+        void __iomem *cfg = spider_get_irq_config(irq);
+        irq = spider_get_nr(irq);
+
+        out_be32(cfg, in_be32(cfg) | 0x3107000eu);
+        out_be32(cfg + 4, in_be32(cfg + 4) | 0x00020000u | irq);
+}
+
+static void spider_disable_irq(unsigned int irq)
+{
+        void __iomem *cfg = spider_get_irq_config(irq);
+        irq = spider_get_nr(irq);
+
+        out_be32(cfg, in_be32(cfg) & ~0x30000000u);
+}
+
+static unsigned int spider_startup_irq(unsigned int irq)
+{
+        spider_enable_irq(irq);
+        return 0;
+}
+
+static void spider_shutdown_irq(unsigned int irq)
+{
+        spider_disable_irq(irq);
+}
+
+static void spider_end_irq(unsigned int irq)
+{
+        spider_enable_irq(irq);
+}
+
+static void spider_ack_irq(unsigned int irq)
+{
+        spider_disable_irq(irq);
+        iic_local_enable();
+}
+
+static struct hw_interrupt_type spider_pic = {
+        .typename = " SPIDER   ",
+        .startup = spider_startup_irq,
+        .shutdown = spider_shutdown_irq,
+        .enable = spider_enable_irq,
+        .disable = spider_disable_irq,
+        .ack = spider_ack_irq,
+        .end = spider_end_irq,
+};
+
+
+int spider_get_irq(unsigned long int_pending)
+{
+        void __iomem *regs = spider_get_pic(int_pending);
+        unsigned long cs;
+        int irq;
+
+        cs = in_be32(regs + TIR_CS);
+
+        irq = cs >> 24;
+        if (irq != 63)
+                return irq;
+
+        return -1;
+}
+ 
+void spider_init_IRQ(void)
+{
+        int node;
+        struct device_node *dn;
+        unsigned int *property;
+        long spiderpic;
+        int n;
+
+/* FIXME: detect multiple PICs as soon as the device tree has them */
+        for (node = 0; node < 1; node++) {
+                dn = of_find_node_by_path("/");
+                n = prom_n_addr_cells(dn);
+                property = (unsigned int *) get_property(dn,
+                                "platform-spider-pic", NULL);
+
+                if (!property)
+                        continue;
+                for (spiderpic = 0; n > 0; --n)
+                        spiderpic = (spiderpic << 32) + *property++;
+                printk(KERN_DEBUG "SPIDER addr: %lx\n", spiderpic);
+                spider_pics[node] = __ioremap(spiderpic, 0x800, _PAGE_NO_CACHE);
+                for (n = 0; n < IIC_NUM_EXT; n++) {
+                        int irq = n + IIC_EXT_OFFSET + node * IIC_NODE_STRIDE;
+                        get_irq_desc(irq)->handler = &spider_pic;
+
+                /* do not mask any interrupts because of level */
+                out_be32(spider_pics[node] + TIR_MSK, 0x0);
+                
+                /* disable edge detection clear */
+                /* out_be32(spider_pics[node] + TIR_EDC, 0x0); */
+                
+                /* enable interrupt packets to be output */
+                out_be32(spider_pics[node] + TIR_PIEN,
+                        in_be32(spider_pics[node] + TIR_PIEN) | 0x1);
+                
+                /* Enable the interrupt detection enable bit. Do this last! */
+                out_be32(spider_pics[node] + TIR_DEN,
+                        in_be32(spider_pics[node] +TIR_DEN) | 0x1);
+
+                }
+        }
+}
diff --git a/arch/ppc64/kernel/sys_ppc32.c b/arch/ppc64/kernel/sys_ppc32.c
index 9c8e317c598d..118436e8085a 100644
--- a/arch/ppc64/kernel/sys_ppc32.c
+++ b/arch/ppc64/kernel/sys_ppc32.c
@@ -741,6 +741,7 @@ asmlinkage int sys32_pciconfig_write(u32 bus, u32 dfn, u32 off, u32 len, u32 ubu
 
 asmlinkage int sys32_pciconfig_iobase(u32 which, u32 in_bus, u32 in_devfn)
 {
+#ifdef CONFIG_PCI
         struct pci_controller* hose;
         struct list_head *ln;
         struct pci_bus *bus = NULL;
@@ -786,7 +787,7 @@ asmlinkage int sys32_pciconfig_iobase(u32 which, u32 in_bus, u32 in_devfn)
         case IOBASE_ISA_MEM:
                 return -EINVAL;
         }
-
+#endif  /* CONFIG_PCI */
         return -EOPNOTSUPP;
 }
 
diff --git a/arch/ppc64/kernel/sysfs.c b/arch/ppc64/kernel/sysfs.c
index c8fa6569b2fd..2f704a2cafb1 100644
--- a/arch/ppc64/kernel/sysfs.c
+++ b/arch/ppc64/kernel/sysfs.c
@@ -400,7 +400,12 @@ static int __init topology_init(void)
                 struct cpu *c = &per_cpu(cpu_devices, cpu);
 
 #ifdef CONFIG_NUMA
-                parent = &node_devices[cpu_to_node(cpu)];
+                /* The node to which a cpu belongs can't be known
+                 * until the cpu is made present.
+                 */
+                parent = NULL;
+                if (cpu_present(cpu))
+                        parent = &node_devices[cpu_to_node(cpu)];
 #endif
                 /*
                  * For now, we just see if the system supports making
diff --git a/arch/ppc64/kernel/time.c b/arch/ppc64/kernel/time.c
index 33364a7d2cd2..909462e1adea 100644
--- a/arch/ppc64/kernel/time.c
+++ b/arch/ppc64/kernel/time.c
@@ -91,6 +91,7 @@ unsigned long tb_to_xs;
 unsigned      tb_to_us;
 unsigned long processor_freq;
 DEFINE_SPINLOCK(rtc_lock);
+EXPORT_SYMBOL_GPL(rtc_lock);
 
 unsigned long tb_to_ns_scale;
 unsigned long tb_to_ns_shift;
@@ -98,7 +99,6 @@ unsigned long tb_to_ns_shift;
 struct gettimeofday_struct do_gtod;
 
 extern unsigned long wall_jiffies;
-extern unsigned long lpevent_count;
 extern int smp_tb_synchronized;
 
 extern struct timezone sys_tz;
@@ -107,6 +107,9 @@ void ppc_adjtimex(void);
 
 static unsigned adjusting_time = 0;
 
+unsigned long ppc_proc_freq;
+unsigned long ppc_tb_freq;
+
 static __inline__ void timer_check_rtc(void)
 {
         /*
@@ -363,11 +366,8 @@ int timer_interrupt(struct pt_regs * regs)
         set_dec(next_dec);
 
 #ifdef CONFIG_PPC_ISERIES
-        {
-                struct ItLpQueue *lpq = lpaca->lpqueue_ptr;
-                if (lpq && ItLpQueue_isLpIntPending(lpq))
-                        lpevent_count += ItLpQueue_process(lpq, regs);
-        }
+        if (hvlpevent_is_pending())
+                process_hvlpevents(regs);
 #endif
 
 /* collect purr register values often, for accurate calculations */
@@ -472,6 +472,66 @@ int do_settimeofday(struct timespec *tv)
 
 EXPORT_SYMBOL(do_settimeofday);
 
+#if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_MAPLE) || defined(CONFIG_PPC_BPA)
+void __init generic_calibrate_decr(void)
+{
+        struct device_node *cpu;
+        struct div_result divres;
+        unsigned int *fp;
+        int node_found;
+
+        /*
+         * The cpu node should have a timebase-frequency property
+         * to tell us the rate at which the decrementer counts.
+         */
+        cpu = of_find_node_by_type(NULL, "cpu");
+
+        ppc_tb_freq = DEFAULT_TB_FREQ;          /* hardcoded default */
+        node_found = 0;
+        if (cpu != 0) {
+                fp = (unsigned int *)get_property(cpu, "timebase-frequency",
+                                                  NULL);
+                if (fp != 0) {
+                        node_found = 1;
+                        ppc_tb_freq = *fp;
+                }
+        }
+        if (!node_found)
+                printk(KERN_ERR "WARNING: Estimating decrementer frequency "
+                                "(not found)\n");
+
+        ppc_proc_freq = DEFAULT_PROC_FREQ;
+        node_found = 0;
+        if (cpu != 0) {
+                fp = (unsigned int *)get_property(cpu, "clock-frequency",
+                                                  NULL);
+                if (fp != 0) {
+                        node_found = 1;
+                        ppc_proc_freq = *fp;
+                }
+        }
+        if (!node_found)
+                printk(KERN_ERR "WARNING: Estimating processor frequency "
+                                "(not found)\n");
+
+        of_node_put(cpu);
+
+        printk(KERN_INFO "time_init: decrementer frequency = %lu.%.6lu MHz\n",
+               ppc_tb_freq/1000000, ppc_tb_freq%1000000);
+        printk(KERN_INFO "time_init: processor frequency   = %lu.%.6lu MHz\n",
+               ppc_proc_freq/1000000, ppc_proc_freq%1000000);
+
+        tb_ticks_per_jiffy = ppc_tb_freq / HZ;
+        tb_ticks_per_sec = tb_ticks_per_jiffy * HZ;
+        tb_ticks_per_usec = ppc_tb_freq / 1000000;
+        tb_to_us = mulhwu_scale_factor(ppc_tb_freq, 1000000);
+        div128_by_32(1024*1024, 0, tb_ticks_per_sec, &divres);
+        tb_to_xs = divres.result_low;
+
+        setup_default_decr();
+}
+#endif
+
 void __init time_init(void)
 {
         /* This function is only called on the boot processor */
diff --git a/arch/ppc64/kernel/traps.c b/arch/ppc64/kernel/traps.c
index 7e52cb2605e0..a8d5e83ee89f 100644
--- a/arch/ppc64/kernel/traps.c
+++ b/arch/ppc64/kernel/traps.c
@@ -126,6 +126,10 @@ int die(const char *str, struct pt_regs *regs, long err)
                         printk("POWERMAC ");
                         nl = 1;
                         break;
+                case PLATFORM_BPA:
+                        printk("BPA ");
+                        nl = 1;
+                        break;
         }
         if (nl)
                 printk("\n");
diff --git a/arch/ppc64/kernel/vio.c b/arch/ppc64/kernel/vio.c
index cdd830cb2768..0c0ba71ac0e8 100644
--- a/arch/ppc64/kernel/vio.c
+++ b/arch/ppc64/kernel/vio.c
@@ -41,20 +41,25 @@ static const struct vio_device_id *vio_match_device(
 static struct iommu_table *vio_build_iommu_table(struct vio_dev *);
 static int vio_num_address_cells;
 #endif
-static struct vio_dev *vio_bus_device; /* fake "parent" device */
-
 #ifdef CONFIG_PPC_ISERIES
-static struct vio_dev *__init vio_register_device_iseries(char *type,
-                uint32_t unit_num);
-
 static struct iommu_table veth_iommu_table;
 static struct iommu_table vio_iommu_table;
-
-static struct vio_dev _vio_dev  = {
+#endif
+static struct vio_dev vio_bus_device  = { /* fake "parent" device */
+        .name = vio_bus_device.dev.bus_id,
+        .type = "",
+#ifdef CONFIG_PPC_ISERIES
         .iommu_table = &vio_iommu_table,
-        .dev.bus = &vio_bus_type
+#endif
+        .dev.bus_id = "vio",
+        .dev.bus = &vio_bus_type,
 };
-struct device *iSeries_vio_dev = &_vio_dev.dev;
+
+#ifdef CONFIG_PPC_ISERIES
+static struct vio_dev *__init vio_register_device_iseries(char *type,
+                uint32_t unit_num);
+
+struct device *iSeries_vio_dev = &vio_bus_device.dev;
 EXPORT_SYMBOL(iSeries_vio_dev);
 
 #define device_is_compatible(a, b)      1
@@ -260,18 +265,10 @@ static int __init vio_bus_init(void)
         }
 
         /* the fake parent of all vio devices, just to give us a nice directory */
-        vio_bus_device = kmalloc(sizeof(struct vio_dev), GFP_KERNEL);
-        if (!vio_bus_device) {
-                return 1;
-        }
-        memset(vio_bus_device, 0, sizeof(struct vio_dev));
-        strcpy(vio_bus_device->dev.bus_id, "vio");
-
-        err = device_register(&vio_bus_device->dev);
+        err = device_register(&vio_bus_device.dev);
         if (err) {
                 printk(KERN_WARNING "%s: device_register returned %i\n", __FUNCTION__,
                         err);
-                kfree(vio_bus_device);
                 return err;
         }
 
@@ -300,7 +297,7 @@ static void __devinit vio_dev_release(struct device *dev)
 }
 
 #ifdef CONFIG_PPC_PSERIES
-static ssize_t viodev_show_devspec(struct device *dev, char *buf)
+static ssize_t viodev_show_devspec(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct device_node *of_node = dev->platform_data;
 
@@ -309,7 +306,7 @@ static ssize_t viodev_show_devspec(struct device *dev, char *buf)
 DEVICE_ATTR(devspec, S_IRUSR | S_IRGRP | S_IROTH, viodev_show_devspec, NULL);
 #endif
 
-static ssize_t viodev_show_name(struct device *dev, char *buf)
+static ssize_t viodev_show_name(struct device *dev, struct device_attribute *attr, char *buf)
 {
         return sprintf(buf, "%s\n", to_vio_dev(dev)->name);
 }
@@ -326,7 +323,7 @@ static struct vio_dev * __devinit vio_register_device_common(
         viodev->unit_address = unit_address;
         viodev->iommu_table = iommu_table;
         /* init generic 'struct device' fields: */
-        viodev->dev.parent = &vio_bus_device->dev;
+        viodev->dev.parent = &vio_bus_device.dev;
         viodev->dev.bus = &vio_bus_type;
         viodev->dev.release = vio_dev_release;
 
@@ -636,5 +633,3 @@ struct bus_type vio_bus_type = {
         .name = "vio",
         .match = vio_bus_match,
 };
-
-EXPORT_SYMBOL(vio_bus_type);
diff --git a/arch/ppc64/kernel/viopath.c b/arch/ppc64/kernel/viopath.c
index 2ed8ee075680..2a6c4f01c45e 100644
--- a/arch/ppc64/kernel/viopath.c
+++ b/arch/ppc64/kernel/viopath.c
@@ -43,12 +43,10 @@
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/iSeries/HvTypes.h>
-#include <asm/iSeries/LparData.h>
+#include <asm/iSeries/ItExtVpdPanel.h>
 #include <asm/iSeries/HvLpEvent.h>
 #include <asm/iSeries/HvLpConfig.h>
-#include <asm/iSeries/HvCallCfg.h>
 #include <asm/iSeries/mf.h>
-#include <asm/iSeries/iSeries_proc.h>
 #include <asm/iSeries/vio.h>
 
 /* Status of the path to each other partition in the system.
@@ -365,7 +363,7 @@ void vio_set_hostlp(void)
          * while we're active
          */
         viopath_ourLp = HvLpConfig_getLpIndex();
-        viopath_hostLp = HvCallCfg_getHostingLpIndex(viopath_ourLp);
+        viopath_hostLp = HvLpConfig_getHostingLpIndex(viopath_ourLp);
 
         if (viopath_hostLp != HvLpIndexInvalid)
                 vio_setHandler(viomajorsubtype_config, handleConfig);
@@ -487,7 +485,7 @@ int viopath_open(HvLpIndex remoteLp, int subtype, int numReq)
         unsigned long flags;
         int tempNumAllocated;
 
-        if ((remoteLp >= HvMaxArchitectedLps) || (remoteLp == HvLpIndexInvalid))
+        if ((remoteLp >= HVMAXARCHITECTEDLPS) || (remoteLp == HvLpIndexInvalid))
                 return -EINVAL;
 
         subtype = subtype >> VIOMAJOR_SUBTYPE_SHIFT;
@@ -558,7 +556,7 @@ int viopath_close(HvLpIndex remoteLp, int subtype, int numReq)
         int numOpen;
         struct alloc_parms parms;
 
-        if ((remoteLp >= HvMaxArchitectedLps) || (remoteLp == HvLpIndexInvalid))
+        if ((remoteLp >= HVMAXARCHITECTEDLPS) || (remoteLp == HvLpIndexInvalid))
                 return -EINVAL;
 
         subtype = subtype >> VIOMAJOR_SUBTYPE_SHIFT;
diff --git a/arch/ppc64/kernel/xics.c b/arch/ppc64/kernel/xics.c
index 879f39b90a33..677c4450984a 100644
--- a/arch/ppc64/kernel/xics.c
+++ b/arch/ppc64/kernel/xics.c
@@ -647,6 +647,31 @@ static void xics_set_affinity(unsigned int virq, cpumask_t cpumask)
         }
 }
 
+void xics_teardown_cpu(void)
+{
+        int cpu = smp_processor_id();
+        int status;
+
+        ops->cppr_info(cpu, 0x00);
+        iosync();
+
+        /*
+         * we need to EOI the IPI if we got here from kexec down IPI
+         *
+         * xics doesn't care if we duplicate an EOI as long as we
+         * don't EOI and raise priority.
+         *
+         * probably need to check all the other interrupts too
+         * should we be flagging idle loop instead?
+         * or creating some task to be scheduled?
+         */
+        ops->xirr_info_set(cpu, XICS_IPI);
+
+        status = rtas_set_indicator(GLOBAL_INTERRUPT_QUEUE,
+                (1UL << interrupt_server_size) - 1 - default_distrib_server, 0);
+        WARN_ON(status != 0);
+}
+
 #ifdef CONFIG_HOTPLUG_CPU
 
 /* Interrupts are disabled. */
diff --git a/arch/ppc64/lib/Makefile b/arch/ppc64/lib/Makefile
index bf7b5bbfc04e..76fbfa9f706f 100644
--- a/arch/ppc64/lib/Makefile
+++ b/arch/ppc64/lib/Makefile
@@ -12,7 +12,7 @@ lib-$(CONFIG_SMP) += locks.o
 
 # e2a provides EBCDIC to ASCII conversions.
 ifdef CONFIG_PPC_ISERIES
-obj-$(CONFIG_PCI)       += e2a.o
+obj-y += e2a.o
 endif
 
 lib-$(CONFIG_DEBUG_KERNEL) += sstep.o
diff --git a/arch/ppc64/mm/Makefile b/arch/ppc64/mm/Makefile
index ac522d57b2a7..3695d00d347f 100644
--- a/arch/ppc64/mm/Makefile
+++ b/arch/ppc64/mm/Makefile
@@ -6,6 +6,6 @@ EXTRA_CFLAGS += -mno-minimal-toc
 
 obj-y := fault.o init.o imalloc.o hash_utils.o hash_low.o tlb.o \
         slb_low.o slb.o stab.o mmap.o
-obj-$(CONFIG_DISCONTIGMEM) += numa.o
+obj-$(CONFIG_NEED_MULTIPLE_NODES) += numa.o
 obj-$(CONFIG_HUGETLB_PAGE) += hugetlbpage.o
 obj-$(CONFIG_PPC_MULTIPLATFORM) += hash_native.o
diff --git a/arch/ppc64/mm/hash_native.c b/arch/ppc64/mm/hash_native.c
index 52b6b9305341..4fec05817d66 100644
--- a/arch/ppc64/mm/hash_native.c
+++ b/arch/ppc64/mm/hash_native.c
@@ -304,6 +304,50 @@ static void native_hpte_invalidate(unsigned long slot, unsigned long va,
         local_irq_restore(flags);
 }
 
+/*
+ * clear all mappings on kexec.  All cpus are in real mode (or they will
+ * be when they isi), and we are the only one left.  We rely on our kernel
+ * mapping being 0xC0's and the hardware ignoring those two real bits.
+ *
+ * TODO: add batching support when enabled.  remember, no dynamic memory here,
+ * athough there is the control page available...
+ */
+static void native_hpte_clear(void)
+{
+        unsigned long slot, slots, flags;
+        HPTE *hptep = htab_address;
+        Hpte_dword0 dw0;
+        unsigned long pteg_count;
+
+        pteg_count = htab_hash_mask + 1;
+
+        local_irq_save(flags);
+
+        /* we take the tlbie lock and hold it.  Some hardware will
+         * deadlock if we try to tlbie from two processors at once.
+         */
+        spin_lock(&native_tlbie_lock);
+
+        slots = pteg_count * HPTES_PER_GROUP;
+
+        for (slot = 0; slot < slots; slot++, hptep++) {
+                /*
+                 * we could lock the pte here, but we are the only cpu
+                 * running,  right?  and for crash dump, we probably
+                 * don't want to wait for a maybe bad cpu.
+                 */
+                dw0 = hptep->dw0.dw0;
+
+                if (dw0.v) {
+                        hptep->dw0.dword0 = 0;
+                        tlbie(slot2va(dw0.avpn, dw0.l, dw0.h, slot), dw0.l);
+                }
+        }
+
+        spin_unlock(&native_tlbie_lock);
+        local_irq_restore(flags);
+}
+
 static void native_flush_hash_range(unsigned long context,
                                     unsigned long number, int local)
 {
@@ -415,7 +459,8 @@ void hpte_init_native(void)
         ppc_md.hpte_updatepp    = native_hpte_updatepp;
         ppc_md.hpte_updateboltedpp = native_hpte_updateboltedpp;
         ppc_md.hpte_insert      = native_hpte_insert;
-        ppc_md.hpte_remove      = native_hpte_remove;
+        ppc_md.hpte_remove      = native_hpte_remove;
+        ppc_md.hpte_clear_all   = native_hpte_clear;
         if (tlb_batching_enabled())
                 ppc_md.flush_hash_range = native_flush_hash_range;
         htab_finish_init();
diff --git a/arch/ppc64/mm/hash_utils.c b/arch/ppc64/mm/hash_utils.c
index 0a0f97008d02..1647b1c6f28e 100644
--- a/arch/ppc64/mm/hash_utils.c
+++ b/arch/ppc64/mm/hash_utils.c
@@ -195,7 +195,7 @@ void __init htab_initialize(void)
                 memset((void *)table, 0, htab_size_bytes);
         }
 
-        mode_rw = _PAGE_ACCESSED | _PAGE_COHERENT | PP_RWXX;
+        mode_rw = _PAGE_ACCESSED | _PAGE_DIRTY | _PAGE_COHERENT | PP_RWXX;
 
         /* On U3 based machines, we need to reserve the DART area and
          * _NOT_ map it to avoid cache paradoxes as it's remapped non
@@ -310,10 +310,6 @@ int hash_page(unsigned long ea, unsigned long access, unsigned long trap)
 
                 vsid = get_vsid(mm->context.id, ea);
                 break;
-        case IO_REGION_ID:
-                mm = &ioremap_mm;
-                vsid = get_kernel_vsid(ea);
-                break;
         case VMALLOC_REGION_ID:
                 mm = &init_mm;
                 vsid = get_kernel_vsid(ea);
diff --git a/arch/ppc64/mm/hugetlbpage.c b/arch/ppc64/mm/hugetlbpage.c
index d3bf86a5c1ad..fdcfe97c75c1 100644
--- a/arch/ppc64/mm/hugetlbpage.c
+++ b/arch/ppc64/mm/hugetlbpage.c
@@ -121,7 +121,7 @@ static pte_t *hugepte_alloc(struct mm_struct *mm, pud_t *dir, unsigned long addr
         return hugepte_offset(dir, addr);
 }
 
-static pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr)
+pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr)
 {
         pud_t *pud;
 
@@ -134,7 +134,7 @@ static pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr)
         return hugepte_offset(pud, addr);
 }
 
-static pte_t *huge_pte_alloc(struct mm_struct *mm, unsigned long addr)
+pte_t *huge_pte_alloc(struct mm_struct *mm, unsigned long addr)
 {
         pud_t *pud;
 
@@ -147,25 +147,6 @@ static pte_t *huge_pte_alloc(struct mm_struct *mm, unsigned long addr)
         return hugepte_alloc(mm, pud, addr);
 }
 
-static void set_huge_pte(struct mm_struct *mm, struct vm_area_struct *vma,
-                         unsigned long addr, struct page *page,
-                         pte_t *ptep, int write_access)
-{
-        pte_t entry;
-
-        add_mm_counter(mm, rss, HPAGE_SIZE / PAGE_SIZE);
-        if (write_access) {
-                entry =
-                    pte_mkwrite(pte_mkdirty(mk_pte(page, vma->vm_page_prot)));
-        } else {
-                entry = pte_wrprotect(mk_pte(page, vma->vm_page_prot));
-        }
-        entry = pte_mkyoung(entry);
-        entry = pte_mkhuge(entry);
-
-        set_pte_at(mm, addr, ptep, entry);
-}
-
 /*
  * This function checks for proper alignment of input addr and len parameters.
  */
@@ -259,80 +240,6 @@ int prepare_hugepage_range(unsigned long addr, unsigned long len)
         return -EINVAL;
 }
 
-int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src,
-                        struct vm_area_struct *vma)
-{
-        pte_t *src_pte, *dst_pte, entry;
-        struct page *ptepage;
-        unsigned long addr = vma->vm_start;
-        unsigned long end = vma->vm_end;
-        int err = -ENOMEM;
-
-        while (addr < end) {
-                dst_pte = huge_pte_alloc(dst, addr);
-                if (!dst_pte)
-                        goto out;
-
-                src_pte = huge_pte_offset(src, addr);
-                entry = *src_pte;
-                
-                ptepage = pte_page(entry);
-                get_page(ptepage);
-                add_mm_counter(dst, rss, HPAGE_SIZE / PAGE_SIZE);
-                set_pte_at(dst, addr, dst_pte, entry);
-
-                addr += HPAGE_SIZE;
-        }
-
-        err = 0;
- out:
-        return err;
-}
-
-int
-follow_hugetlb_page(struct mm_struct *mm, struct vm_area_struct *vma,
-                    struct page **pages, struct vm_area_struct **vmas,
-                    unsigned long *position, int *length, int i)
-{
-        unsigned long vpfn, vaddr = *position;
-        int remainder = *length;
-
-        WARN_ON(!is_vm_hugetlb_page(vma));
-
-        vpfn = vaddr/PAGE_SIZE;
-        while (vaddr < vma->vm_end && remainder) {
-                if (pages) {
-                        pte_t *pte;
-                        struct page *page;
-
-                        pte = huge_pte_offset(mm, vaddr);
-
-                        /* hugetlb should be locked, and hence, prefaulted */
-                        WARN_ON(!pte || pte_none(*pte));
-
-                        page = &pte_page(*pte)[vpfn % (HPAGE_SIZE/PAGE_SIZE)];
-
-                        WARN_ON(!PageCompound(page));
-
-                        get_page(page);
-                        pages[i] = page;
-                }
-
-                if (vmas)
-                        vmas[i] = vma;
-
-                vaddr += PAGE_SIZE;
-                ++vpfn;
-                --remainder;
-                ++i;
-        }
-
-        *length = remainder;
-        *position = vaddr;
-
-        return i;
-}
-
 struct page *
 follow_huge_addr(struct mm_struct *mm, unsigned long address, int write)
 {
@@ -363,89 +270,6 @@ follow_huge_pmd(struct mm_struct *mm, unsigned long address,
         return NULL;
 }
 
-void unmap_hugepage_range(struct vm_area_struct *vma,
-                          unsigned long start, unsigned long end)
-{
-        struct mm_struct *mm = vma->vm_mm;
-        unsigned long addr;
-        pte_t *ptep;
-        struct page *page;
-
-        WARN_ON(!is_vm_hugetlb_page(vma));
-        BUG_ON((start % HPAGE_SIZE) != 0);
-        BUG_ON((end % HPAGE_SIZE) != 0);
-
-        for (addr = start; addr < end; addr += HPAGE_SIZE) {
-                pte_t pte;
-
-                ptep = huge_pte_offset(mm, addr);
-                if (!ptep || pte_none(*ptep))
-                        continue;
-
-                pte = *ptep;
-                page = pte_page(pte);
-                pte_clear(mm, addr, ptep);
-
-                put_page(page);
-        }
-        add_mm_counter(mm, rss, -((end - start) >> PAGE_SHIFT));
-        flush_tlb_pending();
-}
-
-int hugetlb_prefault(struct address_space *mapping, struct vm_area_struct *vma)
-{
-        struct mm_struct *mm = current->mm;
-        unsigned long addr;
-        int ret = 0;
-
-        WARN_ON(!is_vm_hugetlb_page(vma));
-        BUG_ON((vma->vm_start % HPAGE_SIZE) != 0);
-        BUG_ON((vma->vm_end % HPAGE_SIZE) != 0);
-
-        spin_lock(&mm->page_table_lock);
-        for (addr = vma->vm_start; addr < vma->vm_end; addr += HPAGE_SIZE) {
-                unsigned long idx;
-                pte_t *pte = huge_pte_alloc(mm, addr);
-                struct page *page;
-
-                if (!pte) {
-                        ret = -ENOMEM;
-                        goto out;
-                }
-                if (! pte_none(*pte))
-                        continue;
-
-                idx = ((addr - vma->vm_start) >> HPAGE_SHIFT)
-                        + (vma->vm_pgoff >> (HPAGE_SHIFT - PAGE_SHIFT));
-                page = find_get_page(mapping, idx);
-                if (!page) {
-                        /* charge the fs quota first */
-                        if (hugetlb_get_quota(mapping)) {
-                                ret = -ENOMEM;
-                                goto out;
-                        }
-                        page = alloc_huge_page();
-                        if (!page) {
-                                hugetlb_put_quota(mapping);
-                                ret = -ENOMEM;
-                                goto out;
-                        }
-                        ret = add_to_page_cache(page, mapping, idx, GFP_ATOMIC);
-                        if (! ret) {
-                                unlock_page(page);
-                        } else {
-                                hugetlb_put_quota(mapping);
-                                free_huge_page(page);
-                                goto out;
-                        }
-                }
-                set_huge_pte(mm, vma, addr, page, pte, vma->vm_flags & VM_WRITE);
-        }
-out:
-        spin_unlock(&mm->page_table_lock);
-        return ret;
-}
-
 /* Because we have an exclusive hugepage region which lies within the
  * normal user address space, we have to take special measures to make
  * non-huge mmap()s evade the hugepage reserved regions. */
@@ -468,7 +292,12 @@ unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr,
                     && !is_hugepage_only_range(mm, addr,len))
                         return addr;
         }
-        start_addr = addr = mm->free_area_cache;
+        if (len > mm->cached_hole_size) {
+                start_addr = addr = mm->free_area_cache;
+        } else {
+                start_addr = addr = TASK_UNMAPPED_BASE;
+                mm->cached_hole_size = 0;
+        }
 
 full_search:
         vma = find_vma(mm, addr);
@@ -492,6 +321,8 @@ full_search:
                         mm->free_area_cache = addr + len;
                         return addr;
                 }
+                if (addr + mm->cached_hole_size < vma->vm_start)
+                        mm->cached_hole_size = vma->vm_start - addr;
                 addr = vma->vm_end;
                 vma = vma->vm_next;
         }
@@ -499,6 +330,7 @@ full_search:
         /* Make sure we didn't miss any holes */
         if (start_addr != TASK_UNMAPPED_BASE) {
                 start_addr = addr = TASK_UNMAPPED_BASE;
+                mm->cached_hole_size = 0;
                 goto full_search;
         }
         return -ENOMEM;
@@ -520,6 +352,7 @@ arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0,
         struct vm_area_struct *vma, *prev_vma;
         struct mm_struct *mm = current->mm;
         unsigned long base = mm->mmap_base, addr = addr0;
+        unsigned long largest_hole = mm->cached_hole_size;
         int first_time = 1;
 
         /* requested length too big for entire address space */
@@ -540,6 +373,10 @@ arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0,
                         return addr;
         }
 
+        if (len <= largest_hole) {
+                largest_hole = 0;
+                mm->free_area_cache = base;
+        }
 try_again:
         /* make sure it can fit in the remaining address space */
         if (mm->free_area_cache < len)
@@ -568,13 +405,21 @@ hugepage_recheck:
                  * vma->vm_start, use it:
                  */
                 if (addr+len <= vma->vm_start &&
-                                (!prev_vma || (addr >= prev_vma->vm_end)))
+                          (!prev_vma || (addr >= prev_vma->vm_end))) {
                         /* remember the address as a hint for next time */
-                        return (mm->free_area_cache = addr);
-                else
+                        mm->cached_hole_size = largest_hole;
+                        return (mm->free_area_cache = addr);
+                } else {
                         /* pull free_area_cache down to the first hole */
-                        if (mm->free_area_cache == vma->vm_end)
+                        if (mm->free_area_cache == vma->vm_end) {
                                 mm->free_area_cache = vma->vm_start;
+                                mm->cached_hole_size = largest_hole;
+                        }
+                }
+
+                /* remember the largest hole we saw so far */
+                if (addr + largest_hole < vma->vm_start)
+                        largest_hole = vma->vm_start - addr;
 
                 /* try just below the current vma->vm_start */
                 addr = vma->vm_start-len;
@@ -587,6 +432,7 @@ fail:
          */
         if (first_time) {
                 mm->free_area_cache = base;
+                largest_hole = 0;
                 first_time = 0;
                 goto try_again;
         }
@@ -597,11 +443,13 @@ fail:
          * allocations.
          */
         mm->free_area_cache = TASK_UNMAPPED_BASE;
+        mm->cached_hole_size = ~0UL;
         addr = arch_get_unmapped_area(filp, addr0, len, pgoff, flags);
         /*
          * Restore the topdown base:
          */
         mm->free_area_cache = base;
+        mm->cached_hole_size = ~0UL;
 
         return addr;
 }
diff --git a/arch/ppc64/mm/imalloc.c b/arch/ppc64/mm/imalloc.c
index cb8727f3267a..b6e75b891ac0 100644
--- a/arch/ppc64/mm/imalloc.c
+++ b/arch/ppc64/mm/imalloc.c
@@ -15,6 +15,7 @@
 #include <asm/pgtable.h>
 #include <asm/semaphore.h>
 #include <asm/imalloc.h>
+#include <asm/cacheflush.h>
 
 static DECLARE_MUTEX(imlist_sem);
 struct vm_struct * imlist = NULL;
@@ -285,29 +286,32 @@ struct vm_struct * im_get_area(unsigned long v_addr, unsigned long size,
         return area;
 }
 
-unsigned long im_free(void * addr)
+void im_free(void * addr)
 {
         struct vm_struct **p, *tmp;
-        unsigned long ret_size = 0;
   
         if (!addr)
-                return ret_size;
-        if ((PAGE_SIZE-1) & (unsigned long) addr) {
+                return;
+        if ((unsigned long) addr & ~PAGE_MASK) {
                 printk(KERN_ERR "Trying to %s bad address (%p)\n", __FUNCTION__,                        addr);
-                return ret_size;
+                return;
         }
         down(&imlist_sem);
         for (p = &imlist ; (tmp = *p) ; p = &tmp->next) {
                 if (tmp->addr == addr) {
-                        ret_size = tmp->size;
                         *p = tmp->next;
+
+                        /* XXX: do we need the lock? */
+                        spin_lock(&init_mm.page_table_lock);
+                        unmap_vm_area(tmp);
+                        spin_unlock(&init_mm.page_table_lock);
+
                         kfree(tmp);
                         up(&imlist_sem);
-                        return ret_size;
+                        return;
                 }
         }
         up(&imlist_sem);
         printk(KERN_ERR "Trying to %s nonexistent area (%p)\n", __FUNCTION__,
                         addr);
-        return ret_size;
 }
diff --git a/arch/ppc64/mm/init.c b/arch/ppc64/mm/init.c
index 4b42aff74d73..b50b3a446dbe 100644
--- a/arch/ppc64/mm/init.c
+++ b/arch/ppc64/mm/init.c
@@ -73,9 +73,6 @@ static unsigned long phbs_io_bot = PHBS_IO_BASE;
 extern pgd_t swapper_pg_dir[];
 extern struct task_struct *current_set[NR_CPUS];
 
-extern pgd_t ioremap_dir[];
-pgd_t * ioremap_pgd = (pgd_t *)&ioremap_dir;
-
 unsigned long klimit = (unsigned long)_end;
 
 unsigned long _SDR1=0;
@@ -101,7 +98,7 @@ void show_mem(void)
         printk("Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
         for_each_pgdat(pgdat) {
                 for (i = 0; i < pgdat->node_spanned_pages; i++) {
-                        page = pgdat->node_mem_map + i;
+                        page = pgdat_page_nr(pgdat, i);
                         total++;
                         if (PageReserved(page))
                                 reserved++;
@@ -137,69 +134,6 @@ void iounmap(volatile void __iomem *addr)
 
 #else
 
-static void unmap_im_area_pte(pmd_t *pmd, unsigned long addr,
-                                  unsigned long end)
-{
-        pte_t *pte;
-
-        pte = pte_offset_kernel(pmd, addr);
-        do {
-                pte_t ptent = ptep_get_and_clear(&ioremap_mm, addr, pte);
-                WARN_ON(!pte_none(ptent) && !pte_present(ptent));
-        } while (pte++, addr += PAGE_SIZE, addr != end);
-}
-
-static inline void unmap_im_area_pmd(pud_t *pud, unsigned long addr,
-                                     unsigned long end)
-{
-        pmd_t *pmd;
-        unsigned long next;
-
-        pmd = pmd_offset(pud, addr);
-        do {
-                next = pmd_addr_end(addr, end);
-                if (pmd_none_or_clear_bad(pmd))
-                        continue;
-                unmap_im_area_pte(pmd, addr, next);
-        } while (pmd++, addr = next, addr != end);
-}
-
-static inline void unmap_im_area_pud(pgd_t *pgd, unsigned long addr,
-                                     unsigned long end)
-{
-        pud_t *pud;
-        unsigned long next;
-
-        pud = pud_offset(pgd, addr);
-        do {
-                next = pud_addr_end(addr, end);
-                if (pud_none_or_clear_bad(pud))
-                        continue;
-                unmap_im_area_pmd(pud, addr, next);
-        } while (pud++, addr = next, addr != end);
-}
-
-static void unmap_im_area(unsigned long addr, unsigned long end)
-{
-        struct mm_struct *mm = &ioremap_mm;
-        unsigned long next;
-        pgd_t *pgd;
-
-        spin_lock(&mm->page_table_lock);
-
-        pgd = pgd_offset_i(addr);
-        flush_cache_vunmap(addr, end);
-        do {
-                next = pgd_addr_end(addr, end);
-                if (pgd_none_or_clear_bad(pgd))
-                        continue;
-                unmap_im_area_pud(pgd, addr, next);
-        } while (pgd++, addr = next, addr != end);
-        flush_tlb_kernel_range(start, end);
-
-        spin_unlock(&mm->page_table_lock);
-}
-
 /*
  * map_io_page currently only called by __ioremap
  * map_io_page adds an entry to the ioremap page table
@@ -214,21 +148,21 @@ static int map_io_page(unsigned long ea, unsigned long pa, int flags)
         unsigned long vsid;
 
         if (mem_init_done) {
-                spin_lock(&ioremap_mm.page_table_lock);
-                pgdp = pgd_offset_i(ea);
-                pudp = pud_alloc(&ioremap_mm, pgdp, ea);
+                spin_lock(&init_mm.page_table_lock);
+                pgdp = pgd_offset_k(ea);
+                pudp = pud_alloc(&init_mm, pgdp, ea);
                 if (!pudp)
                         return -ENOMEM;
-                pmdp = pmd_alloc(&ioremap_mm, pudp, ea);
+                pmdp = pmd_alloc(&init_mm, pudp, ea);
                 if (!pmdp)
                         return -ENOMEM;
-                ptep = pte_alloc_kernel(&ioremap_mm, pmdp, ea);
+                ptep = pte_alloc_kernel(&init_mm, pmdp, ea);
                 if (!ptep)
                         return -ENOMEM;
                 pa = abs_to_phys(pa);
-                set_pte_at(&ioremap_mm, ea, ptep, pfn_pte(pa >> PAGE_SHIFT,
+                set_pte_at(&init_mm, ea, ptep, pfn_pte(pa >> PAGE_SHIFT,
                                                           __pgprot(flags)));
-                spin_unlock(&ioremap_mm.page_table_lock);
+                spin_unlock(&init_mm.page_table_lock);
         } else {
                 unsigned long va, vpn, hash, hpteg;
 
@@ -267,13 +201,9 @@ static void __iomem * __ioremap_com(unsigned long addr, unsigned long pa,
 
         for (i = 0; i < size; i += PAGE_SIZE)
                 if (map_io_page(ea+i, pa+i, flags))
-                        goto failure;
+                        return NULL;
 
         return (void __iomem *) (ea + (addr & ~PAGE_MASK));
- failure:
-        if (mem_init_done)
-                unmap_im_area(ea, ea + size);
-        return NULL;
 }
 
 
@@ -381,19 +311,14 @@ int __ioremap_explicit(unsigned long pa, unsigned long ea,
  */
 void iounmap(volatile void __iomem *token)
 {
-        unsigned long address, size;
         void *addr;
 
         if (!mem_init_done)
                 return;
         
         addr = (void *) ((unsigned long __force) token & PAGE_MASK);
-        
-        if ((size = im_free(addr)) == 0)
-                return;
 
-        address = (unsigned long)addr; 
-        unmap_im_area(address, address + size);
+        im_free(addr);
 }
 
 static int iounmap_subset_regions(unsigned long addr, unsigned long size)
@@ -606,7 +531,7 @@ EXPORT_SYMBOL(page_is_ram);
  * Initialize the bootmem system and give it all the memory we
  * have available.
  */
-#ifndef CONFIG_DISCONTIGMEM
+#ifndef CONFIG_NEED_MULTIPLE_NODES
 void __init do_init_bootmem(void)
 {
         unsigned long i;
@@ -628,12 +553,20 @@ void __init do_init_bootmem(void)
 
         max_pfn = max_low_pfn;
 
-        /* add all physical memory to the bootmem map. Also find the first */
+        /* Add all physical memory to the bootmem map, mark each area
+         * present.
+         */
         for (i=0; i < lmb.memory.cnt; i++) {
                 unsigned long physbase, size;
+                unsigned long start_pfn, end_pfn;
 
                 physbase = lmb.memory.region[i].physbase;
                 size = lmb.memory.region[i].size;
+
+                start_pfn = physbase >> PAGE_SHIFT;
+                end_pfn = start_pfn + (size >> PAGE_SHIFT);
+                memory_present(0, start_pfn, end_pfn);
+
                 free_bootmem(physbase, size);
         }
 
@@ -672,7 +605,7 @@ void __init paging_init(void)
         free_area_init_node(0, NODE_DATA(0), zones_size,
                             __pa(PAGE_OFFSET) >> PAGE_SHIFT, zholes_size);
 }
-#endif /* CONFIG_DISCONTIGMEM */
+#endif /* ! CONFIG_NEED_MULTIPLE_NODES */
 
 static struct kcore_list kcore_vmem;
 
@@ -703,7 +636,7 @@ module_init(setup_kcore);
 
 void __init mem_init(void)
 {
-#ifdef CONFIG_DISCONTIGMEM
+#ifdef CONFIG_NEED_MULTIPLE_NODES
         int nid;
 #endif
         pg_data_t *pgdat;
@@ -714,7 +647,7 @@ void __init mem_init(void)
         num_physpages = max_low_pfn;    /* RAM is assumed contiguous */
         high_memory = (void *) __va(max_low_pfn * PAGE_SIZE);
 
-#ifdef CONFIG_DISCONTIGMEM
+#ifdef CONFIG_NEED_MULTIPLE_NODES
         for_each_online_node(nid) {
                 if (NODE_DATA(nid)->node_spanned_pages != 0) {
                         printk("freeing bootmem node %x\n", nid);
@@ -729,7 +662,7 @@ void __init mem_init(void)
 
         for_each_pgdat(pgdat) {
                 for (i = 0; i < pgdat->node_spanned_pages; i++) {
-                        page = pgdat->node_mem_map + i;
+                        page = pgdat_page_nr(pgdat, i);
                         if (PageReserved(page))
                                 reservedpages++;
                 }
diff --git a/arch/ppc64/mm/numa.c b/arch/ppc64/mm/numa.c
index ea862ec643d3..cafd91aef289 100644
--- a/arch/ppc64/mm/numa.c
+++ b/arch/ppc64/mm/numa.c
@@ -440,6 +440,8 @@ new_range:
                 for (i = start ; i < (start+size); i += MEMORY_INCREMENT)
                         numa_memory_lookup_table[i >> MEMORY_INCREMENT_SHIFT] =
                                 numa_domain;
+                memory_present(numa_domain, start >> PAGE_SHIFT,
+                                                (start + size) >> PAGE_SHIFT);
 
                 if (--ranges)
                         goto new_range;
@@ -481,6 +483,7 @@ static void __init setup_nonnuma(void)
 
         for (i = 0 ; i < top_of_ram; i += MEMORY_INCREMENT)
                 numa_memory_lookup_table[i >> MEMORY_INCREMENT_SHIFT] = 0;
+        memory_present(0, 0, init_node_data[0].node_end_pfn);
 }
 
 static void __init dump_numa_topology(void)
diff --git a/arch/ppc64/xmon/xmon.c b/arch/ppc64/xmon/xmon.c
index 3c0ccb2623ae..7f6e13a4b71e 100644
--- a/arch/ppc64/xmon/xmon.c
+++ b/arch/ppc64/xmon/xmon.c
@@ -2247,7 +2247,14 @@ scanhex(unsigned long *vp)
                         tmpstr[i] = c;
                 }
                 tmpstr[i++] = 0;
-                *vp = kallsyms_lookup_name(tmpstr);
+                *vp = 0;
+                if (setjmp(bus_error_jmp) == 0) {
+                        catch_memory_errors = 1;
+                        sync();
+                        *vp = kallsyms_lookup_name(tmpstr);
+                        sync();
+                }
+                catch_memory_errors = 0;
                 if (!(*vp)) {
                         printf("unknown symbol '%s'\n", tmpstr);
                         return 0;