261 files changed, 7374 insertions, 13206 deletions

diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index 50b9afa8ae6d..5959e36c3b4c 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -180,6 +180,7 @@ config ARCH_OMAP
 config ARCH_VERSATILE
         bool "Versatile"
         select ARM_AMBA
+        select ARM_VIC
         select ICST307
         help
           This enables support for ARM Ltd Versatile board.
@@ -400,6 +401,38 @@ config NO_IDLE_HZ
           Currently at least OMAP, PXA2xx and SA11x0 platforms are known
           to have accurate timekeeping with dynamic tick.
 
+config AEABI
+        bool "Use the ARM EABI to compile the kernel"
+        help
+          This option allows for the kernel to be compiled using the latest
+          ARM ABI (aka EABI).  This is only useful if you are using a user
+          space environment that is also compiled with EABI.
+
+          Since there are major incompatibilities between the legacy ABI and
+          EABI, especially with regard to structure member alignment, this
+          option also changes the kernel syscall calling convention to
+          disambiguate both ABIs and allow for backward compatibility support
+          (selected with CONFIG_OABI_COMPAT).
+
+          To use this you need GCC version 4.0.0 or later.
+
+config OABI_COMPAT
+        bool "Allow old ABI binaries to run with this kernel"
+        depends on AEABI
+        default y
+        help
+          This option preserves the old syscall interface along with the
+          new (ARM EABI) one. It also provides a compatibility layer to
+          intercept syscalls that have structure arguments which layout
+          in memory differs between the legacy ABI and the new ARM EABI
+          (only for non "thumb" binaries). This option adds a tiny
+          overhead to all syscalls and produces a slightly larger kernel.
+          If you know you'll be using only pure EABI user space then you
+          can say N here. If this option is not selected and you attempt
+          to execute a legacy ABI binary then the result will be
+          UNPREDICTABLE (in fact it can be predicted that it won't work
+          at all). If in doubt say Y.
+
 config ARCH_DISCONTIGMEM_ENABLE
         bool
         default (ARCH_LH7A40X && !LH7A40X_CONTIGMEM)
@@ -586,6 +619,7 @@ comment "At least one emulation must be selected"
 
 config FPE_NWFPE
         bool "NWFPE math emulation"
+        depends on !AEABI || OABI_COMPAT
         ---help---
           Say Y to include the NWFPE floating point emulator in the kernel.
           This is necessary to run most binaries. Linux does not currently
@@ -609,7 +643,7 @@ config FPE_NWFPE_XP
 
 config FPE_FASTFPE
         bool "FastFPE math emulation (EXPERIMENTAL)"
-        depends on !CPU_32v3 && EXPERIMENTAL
+        depends on (!AEABI || OABI_COMPAT) && !CPU_32v3 && EXPERIMENTAL
         ---help---
           Say Y here to include the FAST floating point emulator in the kernel.
           This is an experimental much faster emulator which now also has full
@@ -641,6 +675,7 @@ source "fs/Kconfig.binfmt"
 
 config ARTHUR
         tristate "RISC OS personality"
+        depends on !AEABI
         help
           Say Y here to include the kernel code necessary if you want to run
           Acorn RISC OS/Arthur binaries under Linux. This code is still very
@@ -729,6 +764,8 @@ source "drivers/char/Kconfig"
 
 source "drivers/i2c/Kconfig"
 
+source "drivers/spi/Kconfig"
+
 source "drivers/hwmon/Kconfig"
 
 #source "drivers/l3/Kconfig"
diff --git a/arch/arm/Makefile b/arch/arm/Makefile
index 1fa2a1011584..fbfc14a56b96 100644
--- a/arch/arm/Makefile
+++ b/arch/arm/Makefile
@@ -56,8 +56,13 @@ tune-$(CONFIG_CPU_SA1100)	:=-mtune=strongarm1100
 tune-$(CONFIG_CPU_XSCALE)       :=$(call cc-option,-mtune=xscale,-mtune=strongarm110) -Wa,-mcpu=xscale
 tune-$(CONFIG_CPU_V6)           :=$(call cc-option,-mtune=arm1136j-s,-mtune=strongarm)
 
-# Need -Uarm for gcc < 3.x
+ifeq ($(CONFIG_AEABI),y)
+CFLAGS_ABI      :=-mabi=aapcs -mno-thumb-interwork
+else
 CFLAGS_ABI      :=$(call cc-option,-mapcs-32,-mabi=apcs-gnu) $(call cc-option,-mno-thumb-interwork,)
+endif
+
+# Need -Uarm for gcc < 3.x
 CFLAGS          +=$(CFLAGS_ABI) $(arch-y) $(tune-y) $(call cc-option,-mshort-load-bytes,$(call cc-option,-malignment-traps,)) -msoft-float -Uarm
 AFLAGS          +=$(CFLAGS_ABI) $(arch-y) $(tune-y) -msoft-float
 
diff --git a/arch/arm/common/Kconfig b/arch/arm/common/Kconfig
index d7509c7a3c5e..5e34ca6d38b6 100644
--- a/arch/arm/common/Kconfig
+++ b/arch/arm/common/Kconfig
@@ -1,7 +1,10 @@
-config ICST525
+config ARM_GIC
         bool
 
-config ARM_GIC
+config ARM_VIC
+        bool
+
+config ICST525
         bool
 
 config ICST307
diff --git a/arch/arm/common/Makefile b/arch/arm/common/Makefile
index ec8d17c96906..c81a2ff6b5be 100644
--- a/arch/arm/common/Makefile
+++ b/arch/arm/common/Makefile
@@ -4,6 +4,7 @@
 
 obj-y                           += rtctime.o
 obj-$(CONFIG_ARM_GIC)           += gic.o
+obj-$(CONFIG_ARM_VIC)           += vic.o
 obj-$(CONFIG_ICST525)           += icst525.o
 obj-$(CONFIG_ICST307)           += icst307.o
 obj-$(CONFIG_SA1111)            += sa1111.o
diff --git a/arch/arm/common/locomo.c b/arch/arm/common/locomo.c
index 1b7eaab02b9e..159ad7ed7a40 100644
--- a/arch/arm/common/locomo.c
+++ b/arch/arm/common/locomo.c
@@ -1103,14 +1103,14 @@ static int locomo_bus_remove(struct device *dev)
 struct bus_type locomo_bus_type = {
         .name           = "locomo-bus",
         .match          = locomo_match,
+        .probe          = locomo_bus_probe,
+        .remove         = locomo_bus_remove,
         .suspend        = locomo_bus_suspend,
         .resume         = locomo_bus_resume,
 };
 
 int locomo_driver_register(struct locomo_driver *driver)
 {
-        driver->drv.probe = locomo_bus_probe;
-        driver->drv.remove = locomo_bus_remove;
         driver->drv.bus = &locomo_bus_type;
         return driver_register(&driver->drv);
 }
diff --git a/arch/arm/common/sa1111.c b/arch/arm/common/sa1111.c
index d0d6e6d2d649..1475089f9b42 100644
--- a/arch/arm/common/sa1111.c
+++ b/arch/arm/common/sa1111.c
@@ -1247,14 +1247,14 @@ static int sa1111_bus_remove(struct device *dev)
 struct bus_type sa1111_bus_type = {
         .name           = "sa1111-rab",
         .match          = sa1111_match,
+        .probe          = sa1111_bus_probe,
+        .remove         = sa1111_bus_remove,
         .suspend        = sa1111_bus_suspend,
         .resume         = sa1111_bus_resume,
 };
 
 int sa1111_driver_register(struct sa1111_driver *driver)
 {
-        driver->drv.probe = sa1111_bus_probe;
-        driver->drv.remove = sa1111_bus_remove;
         driver->drv.bus = &sa1111_bus_type;
         return driver_register(&driver->drv);
 }
diff --git a/arch/arm/common/vic.c b/arch/arm/common/vic.c
new file mode 100644
index 000000000000..a45ed1687a59
--- /dev/null
+++ b/arch/arm/common/vic.c
@@ -0,0 +1,92 @@
+/*
+ *  linux/arch/arm/common/vic.c
+ *
+ *  Copyright (C) 1999 - 2003 ARM Limited
+ *  Copyright (C) 2000 Deep Blue Solutions Ltd
+ *
+ * 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/init.h>
+#include <linux/list.h>
+
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/mach/irq.h>
+#include <asm/hardware/vic.h>
+
+static void __iomem *vic_base;
+
+static void vic_mask_irq(unsigned int irq)
+{
+        irq -= IRQ_VIC_START;
+        writel(1 << irq, vic_base + VIC_INT_ENABLE_CLEAR);
+}
+
+static void vic_unmask_irq(unsigned int irq)
+{
+        irq -= IRQ_VIC_START;
+        writel(1 << irq, vic_base + VIC_INT_ENABLE);
+}
+
+static struct irqchip vic_chip = {
+        .ack    = vic_mask_irq,
+        .mask   = vic_mask_irq,
+        .unmask = vic_unmask_irq,
+};
+
+void __init vic_init(void __iomem *base, u32 vic_sources)
+{
+        unsigned int i;
+
+        vic_base = base;
+
+        /* Disable all interrupts initially. */
+
+        writel(0, vic_base + VIC_INT_SELECT);
+        writel(0, vic_base + VIC_INT_ENABLE);
+        writel(~0, vic_base + VIC_INT_ENABLE_CLEAR);
+        writel(0, vic_base + VIC_IRQ_STATUS);
+        writel(0, vic_base + VIC_ITCR);
+        writel(~0, vic_base + VIC_INT_SOFT_CLEAR);
+
+        /*
+         * Make sure we clear all existing interrupts
+         */
+        writel(0, vic_base + VIC_VECT_ADDR);
+        for (i = 0; i < 19; i++) {
+                unsigned int value;
+
+                value = readl(vic_base + VIC_VECT_ADDR);
+                writel(value, vic_base + VIC_VECT_ADDR);
+        }
+
+        for (i = 0; i < 16; i++) {
+                void __iomem *reg = vic_base + VIC_VECT_CNTL0 + (i * 4);
+                writel(VIC_VECT_CNTL_ENABLE | i, reg);
+        }
+
+        writel(32, vic_base + VIC_DEF_VECT_ADDR);
+
+        for (i = 0; i < 32; i++) {
+                unsigned int irq = IRQ_VIC_START + i;
+
+                set_irq_chip(irq, &vic_chip);
+
+                if (vic_sources & (1 << i)) {
+                        set_irq_handler(irq, do_level_IRQ);
+                        set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
+                }
+        }
+}
diff --git a/arch/arm/kernel/Makefile b/arch/arm/kernel/Makefile
index de94b0f3ee2a..2ce0e3a27a45 100644
--- a/arch/arm/kernel/Makefile
+++ b/arch/arm/kernel/Makefile
@@ -20,6 +20,7 @@ obj-$(CONFIG_ARTHUR)		+= arthur.o
 obj-$(CONFIG_ISA_DMA)           += dma-isa.o
 obj-$(CONFIG_PCI)               += bios32.o
 obj-$(CONFIG_SMP)               += smp.o
+obj-$(CONFIG_OABI_COMPAT)       += sys_oabi-compat.o
 
 obj-$(CONFIG_IWMMXT)            += iwmmxt.o
 AFLAGS_iwmmxt.o                 := -Wa,-mcpu=iwmmxt
diff --git a/arch/arm/kernel/armksyms.c b/arch/arm/kernel/armksyms.c
index 9997098009a9..1574941ebfe1 100644
--- a/arch/arm/kernel/armksyms.c
+++ b/arch/arm/kernel/armksyms.c
@@ -35,6 +35,16 @@ extern void __udivsi3(void);
 extern void __umodsi3(void);
 extern void __do_div64(void);
 
+extern void __aeabi_idiv(void);
+extern void __aeabi_idivmod(void);
+extern void __aeabi_lasr(void);
+extern void __aeabi_llsl(void);
+extern void __aeabi_llsr(void);
+extern void __aeabi_lmul(void);
+extern void __aeabi_uidiv(void);
+extern void __aeabi_uidivmod(void);
+extern void __aeabi_ulcmp(void);
+
 extern void fpundefinstr(void);
 extern void fp_enter(void);
 
@@ -141,6 +151,18 @@ EXPORT_SYMBOL(__udivsi3);
 EXPORT_SYMBOL(__umodsi3);
 EXPORT_SYMBOL(__do_div64);
 
+#ifdef CONFIG_AEABI
+EXPORT_SYMBOL(__aeabi_idiv);
+EXPORT_SYMBOL(__aeabi_idivmod);
+EXPORT_SYMBOL(__aeabi_lasr);
+EXPORT_SYMBOL(__aeabi_llsl);
+EXPORT_SYMBOL(__aeabi_llsr);
+EXPORT_SYMBOL(__aeabi_lmul);
+EXPORT_SYMBOL(__aeabi_uidiv);
+EXPORT_SYMBOL(__aeabi_uidivmod);
+EXPORT_SYMBOL(__aeabi_ulcmp);
+#endif
+
         /* bitops */
 EXPORT_SYMBOL(_set_bit_le);
 EXPORT_SYMBOL(_test_and_set_bit_le);
diff --git a/arch/arm/kernel/calls.S b/arch/arm/kernel/calls.S
index 55076a75e5bf..75e6f9a94713 100644
--- a/arch/arm/kernel/calls.S
+++ b/arch/arm/kernel/calls.S
@@ -13,7 +13,7 @@
 #define NR_syscalls 328
 #else
 
-__syscall_start:
+100:
 /* 0 */         .long   sys_restart_syscall
                 .long   sys_exit
                 .long   sys_fork_wrapper
@@ -27,7 +27,7 @@ __syscall_start:
 /* 10 */        .long   sys_unlink
                 .long   sys_execve_wrapper
                 .long   sys_chdir
-                .long   sys_time                /* used by libc4 */
+                .long   OBSOLETE(sys_time)      /* used by libc4 */
                 .long   sys_mknod
 /* 15 */        .long   sys_chmod
                 .long   sys_lchown16
@@ -36,15 +36,15 @@ __syscall_start:
                 .long   sys_lseek
 /* 20 */        .long   sys_getpid
                 .long   sys_mount
-                .long   sys_oldumount           /* used by libc4 */
+                .long   OBSOLETE(sys_oldumount) /* used by libc4 */
                 .long   sys_setuid16
                 .long   sys_getuid16
-/* 25 */        .long   sys_stime
+/* 25 */        .long   OBSOLETE(sys_stime)
                 .long   sys_ptrace
-                .long   sys_alarm               /* used by libc4 */
+                .long   OBSOLETE(sys_alarm)     /* used by libc4 */
                 .long   sys_ni_syscall          /* was sys_fstat */
                 .long   sys_pause
-/* 30 */        .long   sys_utime               /* used by libc4 */
+/* 30 */        .long   OBSOLETE(sys_utime)     /* used by libc4 */
                 .long   sys_ni_syscall          /* was sys_stty */
                 .long   sys_ni_syscall          /* was sys_getty */
                 .long   sys_access
@@ -90,21 +90,21 @@ __syscall_start:
                 .long   sys_sigpending
                 .long   sys_sethostname
 /* 75 */        .long   sys_setrlimit
-                .long   sys_old_getrlimit       /* used by libc4 */
+                .long   OBSOLETE(sys_old_getrlimit) /* used by libc4 */
                 .long   sys_getrusage
                 .long   sys_gettimeofday
                 .long   sys_settimeofday
 /* 80 */        .long   sys_getgroups16
                 .long   sys_setgroups16
-                .long   old_select              /* used by libc4 */
+                .long   OBSOLETE(old_select)    /* used by libc4 */
                 .long   sys_symlink
                 .long   sys_ni_syscall          /* was sys_lstat */
 /* 85 */        .long   sys_readlink
                 .long   sys_uselib
                 .long   sys_swapon
                 .long   sys_reboot
-                .long   old_readdir             /* used by libc4 */
-/* 90 */        .long   old_mmap                /* used by libc4 */
+                .long   OBSOLETE(old_readdir)   /* used by libc4 */
+/* 90 */        .long   OBSOLETE(old_mmap)      /* used by libc4 */
                 .long   sys_munmap
                 .long   sys_truncate
                 .long   sys_ftruncate
@@ -116,7 +116,7 @@ __syscall_start:
                 .long   sys_statfs
 /* 100 */       .long   sys_fstatfs
                 .long   sys_ni_syscall
-                .long   sys_socketcall
+                .long   OBSOLETE(sys_socketcall)
                 .long   sys_syslog
                 .long   sys_setitimer
 /* 105 */       .long   sys_getitimer
@@ -127,11 +127,11 @@ __syscall_start:
 /* 110 */       .long   sys_ni_syscall          /* was sys_iopl */
                 .long   sys_vhangup
                 .long   sys_ni_syscall
-                .long   sys_syscall             /* call a syscall */
+                .long   OBSOLETE(sys_syscall)   /* call a syscall */
                 .long   sys_wait4
 /* 115 */       .long   sys_swapoff
                 .long   sys_sysinfo
-                .long   sys_ipc
+                .long   OBSOLETE(ABI(sys_ipc, sys_oabi_ipc))
                 .long   sys_fsync
                 .long   sys_sigreturn_wrapper
 /* 120 */       .long   sys_clone_wrapper
@@ -194,8 +194,8 @@ __syscall_start:
                 .long   sys_rt_sigtimedwait
                 .long   sys_rt_sigqueueinfo
                 .long   sys_rt_sigsuspend_wrapper
-/* 180 */       .long   sys_pread64
-                .long   sys_pwrite64
+/* 180 */       .long   ABI(sys_pread64, sys_oabi_pread64)
+                .long   ABI(sys_pwrite64, sys_oabi_pwrite64)
                 .long   sys_chown16
                 .long   sys_getcwd
                 .long   sys_capget
@@ -207,11 +207,11 @@ __syscall_start:
 /* 190 */       .long   sys_vfork_wrapper
                 .long   sys_getrlimit
                 .long   sys_mmap2
-                .long   sys_truncate64
-                .long   sys_ftruncate64
-/* 195 */       .long   sys_stat64
-                .long   sys_lstat64
-                .long   sys_fstat64
+                .long   ABI(sys_truncate64, sys_oabi_truncate64)
+                .long   ABI(sys_ftruncate64, sys_oabi_ftruncate64)
+/* 195 */       .long   ABI(sys_stat64, sys_oabi_stat64)
+                .long   ABI(sys_lstat64, sys_oabi_lstat64)
+                .long   ABI(sys_fstat64, sys_oabi_fstat64)
                 .long   sys_lchown
                 .long   sys_getuid
 /* 200 */       .long   sys_getgid
@@ -235,11 +235,11 @@ __syscall_start:
                 .long   sys_pivot_root
                 .long   sys_mincore
 /* 220 */       .long   sys_madvise
-                .long   sys_fcntl64
+                .long   ABI(sys_fcntl64, sys_oabi_fcntl64)
                 .long   sys_ni_syscall /* TUX */
                 .long   sys_ni_syscall
                 .long   sys_gettid
-/* 225 */       .long   sys_readahead
+/* 225 */       .long   ABI(sys_readahead, sys_oabi_readahead)
                 .long   sys_setxattr
                 .long   sys_lsetxattr
                 .long   sys_fsetxattr
@@ -265,8 +265,8 @@ __syscall_start:
                 .long   sys_exit_group
                 .long   sys_lookup_dcookie
 /* 250 */       .long   sys_epoll_create
-                .long   sys_epoll_ctl
-                .long   sys_epoll_wait
+                .long   ABI(sys_epoll_ctl, sys_oabi_epoll_ctl)
+                .long   ABI(sys_epoll_wait, sys_oabi_epoll_wait)
                 .long   sys_remap_file_pages
                 .long   sys_ni_syscall  /* sys_set_thread_area */
 /* 255 */       .long   sys_ni_syscall  /* sys_get_thread_area */
@@ -280,8 +280,8 @@ __syscall_start:
                 .long   sys_clock_gettime
                 .long   sys_clock_getres
 /* 265 */       .long   sys_clock_nanosleep
-                .long   sys_statfs64
-                .long   sys_fstatfs64
+                .long   sys_statfs64_wrapper
+                .long   sys_fstatfs64_wrapper
                 .long   sys_tgkill
                 .long   sys_utimes
 /* 270 */       .long   sys_arm_fadvise64_64
@@ -312,7 +312,7 @@ __syscall_start:
 /* 295 */       .long   sys_getsockopt
                 .long   sys_sendmsg
                 .long   sys_recvmsg
-                .long   sys_semop
+                .long   ABI(sys_semop, sys_oabi_semop)
                 .long   sys_semget
 /* 300 */       .long   sys_semctl
                 .long   sys_msgsnd
@@ -326,7 +326,7 @@ __syscall_start:
                 .long   sys_add_key
 /* 310 */       .long   sys_request_key
                 .long   sys_keyctl
-                .long   sys_semtimedop
+                .long   ABI(sys_semtimedop, sys_oabi_semtimedop)
 /* vserver */   .long   sys_ni_syscall
                 .long   sys_ioprio_set
 /* 315 */       .long   sys_ioprio_get
@@ -336,9 +336,8 @@ __syscall_start:
                 .long   sys_mbind
 /* 320 */       .long   sys_get_mempolicy
                 .long   sys_set_mempolicy
-__syscall_end:
 
-                .rept   NR_syscalls - (__syscall_end - __syscall_start) / 4
+                .rept   NR_syscalls - (. - 100b) / 4
                         .long   sys_ni_syscall
                 .endr
 #endif
diff --git a/arch/arm/kernel/ecard.c b/arch/arm/kernel/ecard.c
index 96fd91926c9b..74ea29c3205e 100644
--- a/arch/arm/kernel/ecard.c
+++ b/arch/arm/kernel/ecard.c
@@ -1147,9 +1147,11 @@ static void ecard_drv_shutdown(struct device *dev)
         struct ecard_driver *drv = ECARD_DRV(dev->driver);
         struct ecard_request req;
 
-        if (drv->shutdown)
-                drv->shutdown(ec);
-        ecard_release(ec);
+        if (dev->driver) {
+                if (drv->shutdown)
+                        drv->shutdown(ec);
+                ecard_release(ec);
+        }
 
         /*
          * If this card has a loader, call the reset handler.
@@ -1164,9 +1166,6 @@ static void ecard_drv_shutdown(struct device *dev)
 int ecard_register_driver(struct ecard_driver *drv)
 {
         drv->drv.bus = &ecard_bus_type;
-        drv->drv.probe = ecard_drv_probe;
-        drv->drv.remove = ecard_drv_remove;
-        drv->drv.shutdown = ecard_drv_shutdown;
 
         return driver_register(&drv->drv);
 }
@@ -1195,6 +1194,9 @@ struct bus_type ecard_bus_type = {
         .name           = "ecard",
         .dev_attrs      = ecard_dev_attrs,
         .match          = ecard_match,
+        .probe          = ecard_drv_probe,
+        .remove         = ecard_drv_remove,
+        .shutdown       = ecard_drv_shutdown,
 };
 
 static int ecard_bus_init(void)
diff --git a/arch/arm/kernel/entry-armv.S b/arch/arm/kernel/entry-armv.S
index a52baedf6262..874e6bb79405 100644
--- a/arch/arm/kernel/entry-armv.S
+++ b/arch/arm/kernel/entry-armv.S
@@ -3,6 +3,7 @@
  *
  *  Copyright (C) 1996,1997,1998 Russell King.
  *  ARM700 fix by Matthew Godbolt (linux-user@willothewisp.demon.co.uk)
+ *  nommu support by Hyok S. Choi (hyok.choi@samsung.com)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -104,14 +105,24 @@ common_invalid:
 /*
  * SVC mode handlers
  */
+
+#if defined(CONFIG_AEABI) && (__LINUX_ARM_ARCH__ >= 5)
+#define SPFIX(code...) code
+#else
+#define SPFIX(code...)
+#endif
+
         .macro  svc_entry
         sub     sp, sp, #S_FRAME_SIZE
+ SPFIX( tst     sp, #4          )
+ SPFIX( bicne   sp, sp, #4      )
         stmib   sp, {r1 - r12}
 
         ldmia   r0, {r1 - r3}
         add     r5, sp, #S_SP           @ here for interlock avoidance
         mov     r4, #-1                 @  ""  ""      ""       ""
         add     r0, sp, #S_FRAME_SIZE   @  ""  ""      ""       ""
+ SPFIX( addne   r0, r0, #4      )
         str     r1, [sp]                @ save the "real" r0 copied
                                         @ from the exception stack
 
@@ -302,7 +313,14 @@ __pabt_svc:
 
 /*
  * User mode handlers
+ *
+ * EABI note: sp_svc is always 64-bit aligned here, so should S_FRAME_SIZE
  */
+
+#if defined(CONFIG_AEABI) && (__LINUX_ARM_ARCH__ >= 5) && (S_FRAME_SIZE & 7)
+#error "sizeof(struct pt_regs) must be a multiple of 8"
+#endif
+
         .macro  usr_entry
         sub     sp, sp, #S_FRAME_SIZE
         stmib   sp, {r1 - r12}
@@ -538,7 +556,11 @@ ENTRY(__switch_to)
         add     ip, r1, #TI_CPU_SAVE
         ldr     r3, [r2, #TI_TP_VALUE]
         stmia   ip!, {r4 - sl, fp, sp, lr}      @ Store most regs on stack
+#ifndef CONFIG_MMU
+        add     r2, r2, #TI_CPU_DOMAIN
+#else
         ldr     r6, [r2, #TI_CPU_DOMAIN]!
+#endif
 #if __LINUX_ARM_ARCH__ >= 6
 #ifdef CONFIG_CPU_MPCORE
         clrex
@@ -556,7 +578,9 @@ ENTRY(__switch_to)
         mov     r4, #0xffff0fff
         str     r3, [r4, #-15]                  @ TLS val at 0xffff0ff0
 #endif
+#ifdef CONFIG_MMU
         mcr     p15, 0, r6, c3, c0, 0           @ Set domain register
+#endif
 #ifdef CONFIG_VFP
         @ Always disable VFP so we can lazily save/restore the old
         @ state. This occurs in the context of the previous thread.
diff --git a/arch/arm/kernel/entry-common.S b/arch/arm/kernel/entry-common.S
index e2b42997ad33..2b92ce85f97f 100644
--- a/arch/arm/kernel/entry-common.S
+++ b/arch/arm/kernel/entry-common.S
@@ -98,20 +98,14 @@ ENTRY(ret_from_fork)
            run on an ARM7 and we can save a couple of instructions.  
                                                                 --pb */
 #ifdef CONFIG_CPU_ARM710
-        .macro  arm710_bug_check, instr, temp
-        and     \temp, \instr, #0x0f000000      @ check for SWI
-        teq     \temp, #0x0f000000
-        bne     .Larm700bug
-        .endm
-
-.Larm700bug:
+#define A710(code...) code
+.Larm710bug:
         ldmia   sp, {r0 - lr}^                  @ Get calling r0 - lr
         mov     r0, r0
         add     sp, sp, #S_FRAME_SIZE
         subs    pc, lr, #4
 #else
-        .macro  arm710_bug_check, instr, temp
-        .endm
+#define A710(code...)
 #endif
 
         .align  5
@@ -129,14 +123,50 @@ ENTRY(vector_swi)
         /*
          * Get the system call number.
          */
+
+#if defined(CONFIG_OABI_COMPAT)
+
+        /*
+         * If we have CONFIG_OABI_COMPAT then we need to look at the swi
+         * value to determine if it is an EABI or an old ABI call.
+         */
 #ifdef CONFIG_ARM_THUMB
+        tst     r8, #PSR_T_BIT
+        movne   r10, #0                         @ no thumb OABI emulation
+        ldreq   r10, [lr, #-4]                  @ get SWI instruction
+#else
+        ldr     r10, [lr, #-4]                  @ get SWI instruction
+  A710( and     ip, r10, #0x0f000000            @ check for SWI         )
+  A710( teq     ip, #0x0f000000                                         )
+  A710( bne     .Larm710bug                                             )
+#endif
+
+#elif defined(CONFIG_AEABI)
+
+        /*
+         * Pure EABI user space always put syscall number into scno (r7).
+         */
+  A710( ldr     ip, [lr, #-4]                   @ get SWI instruction   )
+  A710( and     ip, ip, #0x0f000000             @ check for SWI         )
+  A710( teq     ip, #0x0f000000                                         )
+  A710( bne     .Larm710bug                                             )
+
+#elif defined(CONFIG_ARM_THUMB)
+
+        /* Legacy ABI only, possibly thumb mode. */
         tst     r8, #PSR_T_BIT                  @ this is SPSR from save_user_regs
         addne   scno, r7, #__NR_SYSCALL_BASE    @ put OS number in
         ldreq   scno, [lr, #-4]
+
 #else
+
+        /* Legacy ABI only. */
         ldr     scno, [lr, #-4]                 @ get SWI instruction
+  A710( and     ip, scno, #0x0f000000           @ check for SWI         )
+  A710( teq     ip, #0x0f000000                                         )
+  A710( bne     .Larm710bug                                             )
+
 #endif
-        arm710_bug_check scno, ip
 
 #ifdef CONFIG_ALIGNMENT_TRAP
         ldr     ip, __cr_alignment
@@ -145,18 +175,31 @@ ENTRY(vector_swi)
 #endif
         enable_irq
 
-        stmdb   sp!, {r4, r5}                   @ push fifth and sixth args
-
         get_thread_info tsk
+        adr     tbl, sys_call_table             @ load syscall table pointer
         ldr     ip, [tsk, #TI_FLAGS]            @ check for syscall tracing
+
+#if defined(CONFIG_OABI_COMPAT)
+        /*
+         * If the swi argument is zero, this is an EABI call and we do nothing.
+         *
+         * If this is an old ABI call, get the syscall number into scno and
+         * get the old ABI syscall table address.
+         */
+        bics    r10, r10, #0xff000000
+        eorne   scno, r10, #__NR_OABI_SYSCALL_BASE
+        ldrne   tbl, =sys_oabi_call_table
+#elif !defined(CONFIG_AEABI)
         bic     scno, scno, #0xff000000         @ mask off SWI op-code
         eor     scno, scno, #__NR_SYSCALL_BASE  @ check OS number
-        adr     tbl, sys_call_table             @ load syscall table pointer
+#endif
+
+        stmdb   sp!, {r4, r5}                   @ push fifth and sixth args
         tst     ip, #_TIF_SYSCALL_TRACE         @ are we tracing syscalls?
         bne     __sys_trace
 
-        adr     lr, ret_fast_syscall            @ return address
         cmp     scno, #NR_syscalls              @ check upper syscall limit
+        adr     lr, ret_fast_syscall            @ return address
         ldrcc   pc, [tbl, scno, lsl #2]         @ call sys_* routine
 
         add     r1, sp, #S_OFF
@@ -171,11 +214,13 @@ ENTRY(vector_swi)
          * context switches, and waiting for our parent to respond.
          */
 __sys_trace:
+        mov     r2, scno
         add     r1, sp, #S_OFF
         mov     r0, #0                          @ trace entry [IP = 0]
         bl      syscall_trace
 
         adr     lr, __sys_trace_return          @ return address
+        mov     scno, r0                        @ syscall number (possibly new)
         add     r1, sp, #S_R0 + S_OFF           @ pointer to regs
         cmp     scno, #NR_syscalls              @ check upper syscall limit
         ldmccia r1, {r0 - r3}                   @ have to reload r0 - r3
@@ -184,6 +229,7 @@ __sys_trace:
 
 __sys_trace_return:
         str     r0, [sp, #S_R0 + S_OFF]!        @ save returned r0
+        mov     r2, scno
         mov     r1, sp
         mov     r0, #1                          @ trace exit [IP = 1]
         bl      syscall_trace
@@ -195,10 +241,24 @@ __sys_trace_return:
 __cr_alignment:
         .word   cr_alignment
 #endif
+        .ltorg
+
+/*
+ * This is the syscall table declaration for native ABI syscalls.
+ * With EABI a couple syscalls are obsolete and defined as sys_ni_syscall.
+ */
+#define ABI(native, compat) native
+#ifdef CONFIG_AEABI
+#define OBSOLETE(syscall) sys_ni_syscall
+#else
+#define OBSOLETE(syscall) syscall
+#endif
 
         .type   sys_call_table, #object
 ENTRY(sys_call_table)
 #include "calls.S"
+#undef ABI
+#undef OBSOLETE
 
 /*============================================================================
  * Special system call wrappers
@@ -207,7 +267,7 @@ ENTRY(sys_call_table)
 @ r8 = syscall table
                 .type   sys_syscall, #function
 sys_syscall:
-                eor     scno, r0, #__NR_SYSCALL_BASE
+                eor     scno, r0, #__NR_OABI_SYSCALL_BASE
                 cmp     scno, #__NR_syscall - __NR_SYSCALL_BASE
                 cmpne   scno, #NR_syscalls      @ check range
                 stmloia sp, {r5, r6}            @ shuffle args
@@ -255,6 +315,16 @@ sys_sigaltstack_wrapper:
                 ldr     r2, [sp, #S_OFF + S_SP]
                 b       do_sigaltstack
 
+sys_statfs64_wrapper:
+                teq     r1, #88
+                moveq   r1, #84
+                b       sys_statfs64
+
+sys_fstatfs64_wrapper:
+                teq     r1, #88
+                moveq   r1, #84
+                b       sys_fstatfs64
+
 /*
  * Note: off_4k (r5) is always units of 4K.  If we can't do the requested
  * offset, we return EINVAL.
@@ -271,3 +341,49 @@ sys_mmap2:
                 str     r5, [sp, #4]
                 b       do_mmap2
 #endif
+
+#ifdef CONFIG_OABI_COMPAT
+
+/*
+ * These are syscalls with argument register differences
+ */
+
+sys_oabi_pread64:
+                stmia   sp, {r3, r4}
+                b       sys_pread64
+
+sys_oabi_pwrite64:
+                stmia   sp, {r3, r4}
+                b       sys_pwrite64
+
+sys_oabi_truncate64:
+                mov     r3, r2
+                mov     r2, r1
+                b       sys_truncate64
+
+sys_oabi_ftruncate64:
+                mov     r3, r2
+                mov     r2, r1
+                b       sys_ftruncate64
+
+sys_oabi_readahead:
+                str     r3, [sp]
+                mov     r3, r2
+                mov     r2, r1
+                b       sys_readahead
+
+/*
+ * Let's declare a second syscall table for old ABI binaries
+ * using the compatibility syscall entries.
+ */
+#define ABI(native, compat) compat
+#define OBSOLETE(syscall) syscall
+
+        .type   sys_oabi_call_table, #object
+ENTRY(sys_oabi_call_table)
+#include "calls.S"
+#undef ABI
+#undef OBSOLETE
+
+#endif
+
diff --git a/arch/arm/kernel/entry-header.S b/arch/arm/kernel/entry-header.S
index 648cfff93138..55c99cdab7d6 100644
--- a/arch/arm/kernel/entry-header.S
+++ b/arch/arm/kernel/entry-header.S
@@ -19,6 +19,7 @@
 @
 @ Most of the stack format comes from struct pt_regs, but with
 @ the addition of 8 bytes for storing syscall args 5 and 6.
+@ This _must_ remain a multiple of 8 for EABI.
 @
 #define S_OFF           8
 
diff --git a/arch/arm/kernel/head.S b/arch/arm/kernel/head.S
index 1e985f2cd70f..1aca1775b28f 100644
--- a/arch/arm/kernel/head.S
+++ b/arch/arm/kernel/head.S
@@ -251,12 +251,11 @@ __turn_mmu_on:
  * r10 = procinfo
  *
  * Returns:
- *  r0, r3, r5, r6, r7 corrupted
+ *  r0, r3, r6, r7 corrupted
  *  r4 = physical page table address
  */
         .type   __create_page_tables, %function
 __create_page_tables:
-        ldr     r5, [r8, #MACHINFO_PHYSRAM]     @ physram
         pgtbl   r4                              @ page table address
 
         /*
@@ -303,7 +302,7 @@ __create_page_tables:
          * Then map first 1MB of ram in case it contains our boot params.
          */
         add     r0, r4, #PAGE_OFFSET >> 18
-        orr     r6, r5, r7
+        orr     r6, r7, #PHYS_OFFSET
         str     r6, [r0]
 
 #ifdef CONFIG_XIP_KERNEL
@@ -311,7 +310,7 @@ __create_page_tables:
          * Map some ram to cover our .data and .bss areas.
          * Mapping 3MB should be plenty.
          */
-        sub     r3, r4, r5
+        sub     r3, r4, #PHYS_OFFSET
         mov     r3, r3, lsr #20
         add     r0, r0, r3, lsl #2
         add     r6, r6, r3, lsl #20
diff --git a/arch/arm/kernel/ptrace.c b/arch/arm/kernel/ptrace.c
index e591f72bcdeb..7b6256bb590e 100644
--- a/arch/arm/kernel/ptrace.c
+++ b/arch/arm/kernel/ptrace.c
@@ -766,6 +766,11 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                                        (unsigned long __user *) data);
                         break;
 
+                case PTRACE_SET_SYSCALL:
+                        ret = 0;
+                        child->ptrace_message = data;
+                        break;
+
                 default:
                         ret = ptrace_request(child, request, addr, data);
                         break;
@@ -774,14 +779,14 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
         return ret;
 }
 
-asmlinkage void syscall_trace(int why, struct pt_regs *regs)
+asmlinkage int syscall_trace(int why, struct pt_regs *regs, int scno)
 {
         unsigned long ip;
 
         if (!test_thread_flag(TIF_SYSCALL_TRACE))
-                return;
+                return scno;
         if (!(current->ptrace & PT_PTRACED))
-                return;
+                return scno;
 
         /*
          * Save IP.  IP is used to denote syscall entry/exit:
@@ -790,6 +795,8 @@ asmlinkage void syscall_trace(int why, struct pt_regs *regs)
         ip = regs->ARM_ip;
         regs->ARM_ip = why;
 
+        current->ptrace_message = scno;
+
         /* the 0x80 provides a way for the tracing parent to distinguish
            between a syscall stop and SIGTRAP delivery */
         ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD)
@@ -804,4 +811,6 @@ asmlinkage void syscall_trace(int why, struct pt_regs *regs)
                 current->exit_code = 0;
         }
         regs->ARM_ip = ip;
+
+        return current->ptrace_message;
 }
diff --git a/arch/arm/kernel/semaphore.c b/arch/arm/kernel/semaphore.c
index 4c31f2923055..981fe5c6ccbe 100644
--- a/arch/arm/kernel/semaphore.c
+++ b/arch/arm/kernel/semaphore.c
@@ -177,41 +177,42 @@ int __down_trylock(struct semaphore * sem)
  * ip contains the semaphore pointer on entry. Save the C-clobbered
  * registers (r0 to r3 and lr), but not ip, as we use it as a return
  * value in some cases..
+ * To remain AAPCS compliant (64-bit stack align) we save r4 as well.
  */
 asm("   .section .sched.text,\"ax\",%progbits   \n\
         .align  5                               \n\
         .globl  __down_failed                   \n\
 __down_failed:                                  \n\
-        stmfd   sp!, {r0 - r3, lr}              \n\
+        stmfd   sp!, {r0 - r4, lr}              \n\
         mov     r0, ip                          \n\
         bl      __down                          \n\
-        ldmfd   sp!, {r0 - r3, pc}              \n\
+        ldmfd   sp!, {r0 - r4, pc}              \n\
                                                 \n\
         .align  5                               \n\
         .globl  __down_interruptible_failed     \n\
 __down_interruptible_failed:                    \n\
-        stmfd   sp!, {r0 - r3, lr}              \n\
+        stmfd   sp!, {r0 - r4, lr}              \n\
         mov     r0, ip                          \n\
         bl      __down_interruptible            \n\
         mov     ip, r0                          \n\
-        ldmfd   sp!, {r0 - r3, pc}              \n\
+        ldmfd   sp!, {r0 - r4, pc}              \n\
                                                 \n\
         .align  5                               \n\
         .globl  __down_trylock_failed           \n\
 __down_trylock_failed:                          \n\
-        stmfd   sp!, {r0 - r3, lr}              \n\
+        stmfd   sp!, {r0 - r4, lr}              \n\
         mov     r0, ip                          \n\
         bl      __down_trylock                  \n\
         mov     ip, r0                          \n\
-        ldmfd   sp!, {r0 - r3, pc}              \n\
+        ldmfd   sp!, {r0 - r4, pc}              \n\
                                                 \n\
         .align  5                               \n\
         .globl  __up_wakeup                     \n\
 __up_wakeup:                                    \n\
-        stmfd   sp!, {r0 - r3, lr}              \n\
+        stmfd   sp!, {r0 - r4, lr}              \n\
         mov     r0, ip                          \n\
         bl      __up                            \n\
-        ldmfd   sp!, {r0 - r3, pc}              \n\
+        ldmfd   sp!, {r0 - r4, pc}              \n\
         ");
 
 EXPORT_SYMBOL(__down_failed);
diff --git a/arch/arm/kernel/sys_arm.c b/arch/arm/kernel/sys_arm.c
index ea569ba482b1..a491de2d9024 100644
--- a/arch/arm/kernel/sys_arm.c
+++ b/arch/arm/kernel/sys_arm.c
@@ -147,6 +147,7 @@ asmlinkage int old_select(struct sel_arg_struct __user *arg)
         return sys_select(a.n, a.inp, a.outp, a.exp, a.tvp);
 }
 
+#if !defined(CONFIG_AEABI) || defined(CONFIG_OABI_COMPAT)
 /*
  * sys_ipc() is the de-multiplexer for the SysV IPC calls..
  *
@@ -226,6 +227,7 @@ asmlinkage int sys_ipc(uint call, int first, int second, int third,
                 return -ENOSYS;
         }
 }
+#endif
 
 /* Fork a new task - this creates a new program thread.
  * This is called indirectly via a small wrapper
diff --git a/arch/arm/kernel/sys_oabi-compat.c b/arch/arm/kernel/sys_oabi-compat.c
new file mode 100644
index 000000000000..eafa8e5284af
--- /dev/null
+++ b/arch/arm/kernel/sys_oabi-compat.c
@@ -0,0 +1,339 @@
+/*
+ *  arch/arm/kernel/sys_oabi-compat.c
+ *
+ *  Compatibility wrappers for syscalls that are used from
+ *  old ABI user space binaries with an EABI kernel.
+ *
+ *  Author:     Nicolas Pitre
+ *  Created:    Oct 7, 2005
+ *  Copyright:  MontaVista Software, Inc.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ */
+
+/*
+ * The legacy ABI and the new ARM EABI have different rules making some
+ * syscalls incompatible especially with structure arguments.
+ * Most notably, Eabi says 64-bit members should be 64-bit aligned instead of
+ * simply word aligned.  EABI also pads structures to the size of the largest
+ * member it contains instead of the invariant 32-bit.
+ *
+ * The following syscalls are affected:
+ *
+ * sys_stat64:
+ * sys_lstat64:
+ * sys_fstat64:
+ *
+ *   struct stat64 has different sizes and some members are shifted
+ *   Compatibility wrappers are needed for them and provided below.
+ *
+ * sys_fcntl64:
+ *
+ *   struct flock64 has different sizes and some members are shifted
+ *   A compatibility wrapper is needed and provided below.
+ *
+ * sys_statfs64:
+ * sys_fstatfs64:
+ *
+ *   struct statfs64 has extra padding with EABI growing its size from
+ *   84 to 88.  This struct is now __attribute__((packed,aligned(4)))
+ *   with a small assembly wrapper to force the sz argument to 84 if it is 88
+ *   to avoid copying the extra padding over user space unexpecting it.
+ *
+ * sys_newuname:
+ *
+ *   struct new_utsname has no padding with EABI.  No problem there.
+ *
+ * sys_epoll_ctl:
+ * sys_epoll_wait:
+ *
+ *   struct epoll_event has its second member shifted also affecting the
+ *   structure size. Compatibility wrappers are needed and provided below.
+ *
+ * sys_ipc:
+ * sys_semop:
+ * sys_semtimedop:
+ *
+ *   struct sembuf loses its padding with EABI.  Since arrays of them are
+ *   used they have to be copyed to remove the padding. Compatibility wrappers
+ *   provided below.
+ */
+
+#include <linux/syscalls.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/fcntl.h>
+#include <linux/eventpoll.h>
+#include <linux/sem.h>
+#include <asm/ipc.h>
+#include <asm/uaccess.h>
+
+struct oldabi_stat64 {
+        unsigned long long st_dev;
+        unsigned int    __pad1;
+        unsigned long   __st_ino;
+        unsigned int    st_mode;
+        unsigned int    st_nlink;
+
+        unsigned long   st_uid;
+        unsigned long   st_gid;
+
+        unsigned long long st_rdev;
+        unsigned int    __pad2;
+
+        long long       st_size;
+        unsigned long   st_blksize;
+        unsigned long long st_blocks;
+
+        unsigned long   st_atime;
+        unsigned long   st_atime_nsec;
+
+        unsigned long   st_mtime;
+        unsigned long   st_mtime_nsec;
+
+        unsigned long   st_ctime;
+        unsigned long   st_ctime_nsec;
+
+        unsigned long long st_ino;
+} __attribute__ ((packed,aligned(4)));
+
+static long cp_oldabi_stat64(struct kstat *stat,
+                             struct oldabi_stat64 __user *statbuf)
+{
+        struct oldabi_stat64 tmp;
+
+        tmp.st_dev = huge_encode_dev(stat->dev);
+        tmp.__pad1 = 0;
+        tmp.__st_ino = stat->ino;
+        tmp.st_mode = stat->mode;
+        tmp.st_nlink = stat->nlink;
+        tmp.st_uid = stat->uid;
+        tmp.st_gid = stat->gid;
+        tmp.st_rdev = huge_encode_dev(stat->rdev);
+        tmp.st_size = stat->size;
+        tmp.st_blocks = stat->blocks;
+        tmp.__pad2 = 0;
+        tmp.st_blksize = stat->blksize;
+        tmp.st_atime = stat->atime.tv_sec;
+        tmp.st_atime_nsec = stat->atime.tv_nsec;
+        tmp.st_mtime = stat->mtime.tv_sec;
+        tmp.st_mtime_nsec = stat->mtime.tv_nsec;
+        tmp.st_ctime = stat->ctime.tv_sec;
+        tmp.st_ctime_nsec = stat->ctime.tv_nsec;
+        tmp.st_ino = stat->ino;
+        return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
+}
+
+asmlinkage long sys_oabi_stat64(char __user * filename,
+                                struct oldabi_stat64 __user * statbuf)
+{
+        struct kstat stat;
+        int error = vfs_stat(filename, &stat);
+        if (!error)
+                error = cp_oldabi_stat64(&stat, statbuf);
+        return error;
+}
+
+asmlinkage long sys_oabi_lstat64(char __user * filename,
+                                 struct oldabi_stat64 __user * statbuf)
+{
+        struct kstat stat;
+        int error = vfs_lstat(filename, &stat);
+        if (!error)
+                error = cp_oldabi_stat64(&stat, statbuf);
+        return error;
+}
+
+asmlinkage long sys_oabi_fstat64(unsigned long fd,
+                                 struct oldabi_stat64 __user * statbuf)
+{
+        struct kstat stat;
+        int error = vfs_fstat(fd, &stat);
+        if (!error)
+                error = cp_oldabi_stat64(&stat, statbuf);
+        return error;
+}
+
+struct oabi_flock64 {
+        short   l_type;
+        short   l_whence;
+        loff_t  l_start;
+        loff_t  l_len;
+        pid_t   l_pid;
+} __attribute__ ((packed,aligned(4)));
+
+asmlinkage long sys_oabi_fcntl64(unsigned int fd, unsigned int cmd,
+                                 unsigned long arg)
+{
+        struct oabi_flock64 user;
+        struct flock64 kernel;
+        mm_segment_t fs = USER_DS; /* initialized to kill a warning */
+        unsigned long local_arg = arg;
+        int ret;
+
+        switch (cmd) {
+        case F_GETLK64:
+        case F_SETLK64:
+        case F_SETLKW64:
+                if (copy_from_user(&user, (struct oabi_flock64 __user *)arg,
+                                   sizeof(user)))
+                        return -EFAULT;
+                kernel.l_type   = user.l_type;
+                kernel.l_whence = user.l_whence;
+                kernel.l_start  = user.l_start;
+                kernel.l_len    = user.l_len;
+                kernel.l_pid    = user.l_pid;
+                local_arg = (unsigned long)&kernel;
+                fs = get_fs();
+                set_fs(KERNEL_DS);
+        }
+
+        ret = sys_fcntl64(fd, cmd, local_arg);
+
+        switch (cmd) {
+        case F_GETLK64:
+                if (!ret) {
+                        user.l_type     = kernel.l_type;
+                        user.l_whence   = kernel.l_whence;
+                        user.l_start    = kernel.l_start;
+                        user.l_len      = kernel.l_len;
+                        user.l_pid      = kernel.l_pid;
+                        if (copy_to_user((struct oabi_flock64 __user *)arg,
+                                         &user, sizeof(user)))
+                                ret = -EFAULT;
+                }
+        case F_SETLK64:
+        case F_SETLKW64:
+                set_fs(fs);
+        }
+
+        return ret;
+}
+
+struct oabi_epoll_event {
+        __u32 events;
+        __u64 data;
+} __attribute__ ((packed,aligned(4)));
+
+asmlinkage long sys_oabi_epoll_ctl(int epfd, int op, int fd,
+                                   struct oabi_epoll_event __user *event)
+{
+        struct oabi_epoll_event user;
+        struct epoll_event kernel;
+        mm_segment_t fs;
+        long ret;
+
+        if (op == EPOLL_CTL_DEL)
+                return sys_epoll_ctl(epfd, op, fd, NULL);
+        if (copy_from_user(&user, event, sizeof(user)))
+                return -EFAULT;
+        kernel.events = user.events;
+        kernel.data   = user.data;
+        fs = get_fs();
+        set_fs(KERNEL_DS);
+        ret = sys_epoll_ctl(epfd, op, fd, &kernel);
+        set_fs(fs);
+        return ret;
+}
+
+asmlinkage long sys_oabi_epoll_wait(int epfd,
+                                    struct oabi_epoll_event __user *events,
+                                    int maxevents, int timeout)
+{
+        struct epoll_event *kbuf;
+        mm_segment_t fs;
+        long ret, err, i;
+
+        if (maxevents <= 0 || maxevents > (INT_MAX/sizeof(struct epoll_event)))
+                return -EINVAL;
+        kbuf = kmalloc(sizeof(*kbuf) * maxevents, GFP_KERNEL);
+        if (!kbuf)
+                return -ENOMEM;
+        fs = get_fs();
+        set_fs(KERNEL_DS);
+        ret = sys_epoll_wait(epfd, kbuf, maxevents, timeout);
+        set_fs(fs);
+        err = 0;
+        for (i = 0; i < ret; i++) {
+                __put_user_error(kbuf[i].events, &events->events, err);
+                __put_user_error(kbuf[i].data,   &events->data,   err);
+                events++;
+        }
+        kfree(kbuf);
+        return err ? -EFAULT : ret;
+}
+
+struct oabi_sembuf {
+        unsigned short  sem_num;
+        short           sem_op;
+        short           sem_flg;
+        unsigned short  __pad;
+};
+
+asmlinkage long sys_oabi_semtimedop(int semid,
+                                    struct oabi_sembuf __user *tsops,
+                                    unsigned nsops,
+                                    const struct timespec __user *timeout)
+{
+        struct sembuf *sops;
+        struct timespec local_timeout;
+        long err;
+        int i;
+
+        if (nsops < 1)
+                return -EINVAL;
+        sops = kmalloc(sizeof(*sops) * nsops, GFP_KERNEL);
+        if (!sops)
+                return -ENOMEM;
+        err = 0;
+        for (i = 0; i < nsops; i++) {
+                __get_user_error(sops[i].sem_num, &tsops->sem_num, err);
+                __get_user_error(sops[i].sem_op,  &tsops->sem_op,  err);
+                __get_user_error(sops[i].sem_flg, &tsops->sem_flg, err);
+                tsops++;
+        }
+        if (timeout) {
+                /* copy this as well before changing domain protection */
+                err |= copy_from_user(&local_timeout, timeout, sizeof(*timeout));
+                timeout = &local_timeout;
+        }
+        if (err) {
+                err = -EFAULT;
+        } else {
+                mm_segment_t fs = get_fs();
+                set_fs(KERNEL_DS);
+                err = sys_semtimedop(semid, sops, nsops, timeout);
+                set_fs(fs);
+        }
+        kfree(sops);
+        return err;
+}
+
+asmlinkage long sys_oabi_semop(int semid, struct oabi_sembuf __user *tsops,
+                               unsigned nsops)
+{
+        return sys_oabi_semtimedop(semid, tsops, nsops, NULL);
+}
+
+extern asmlinkage int sys_ipc(uint call, int first, int second, int third,
+                              void __user *ptr, long fifth);
+
+asmlinkage int sys_oabi_ipc(uint call, int first, int second, int third,
+                            void __user *ptr, long fifth)
+{
+        switch (call & 0xffff) {
+        case SEMOP:
+                return  sys_oabi_semtimedop(first,
+                                            (struct oabi_sembuf __user *)ptr,
+                                            second, NULL);
+        case SEMTIMEDOP:
+                return  sys_oabi_semtimedop(first,
+                                            (struct oabi_sembuf __user *)ptr,
+                                            second,
+                                            (const struct timespec __user *)fifth);
+        default:
+                return sys_ipc(call, first, second, third, ptr, fifth);
+        }
+}
diff --git a/arch/arm/kernel/traps.c b/arch/arm/kernel/traps.c
index 93cfd3ffcc72..10235b01582e 100644
--- a/arch/arm/kernel/traps.c
+++ b/arch/arm/kernel/traps.c
@@ -404,7 +404,7 @@ asmlinkage int arm_syscall(int no, struct pt_regs *regs)
         struct thread_info *thread = current_thread_info();
         siginfo_t info;
 
-        if ((no >> 16) != 0x9f)
+        if ((no >> 16) != (__ARM_NR_BASE>> 16))
                 return bad_syscall(no, regs);
 
         switch (no & 0xffff) {
diff --git a/arch/arm/lib/ashldi3.S b/arch/arm/lib/ashldi3.S
index 561e20717b30..55e57a1c2e6d 100644
--- a/arch/arm/lib/ashldi3.S
+++ b/arch/arm/lib/ashldi3.S
@@ -37,6 +37,7 @@ Boston, MA 02110-1301, USA.  */
 #endif
 
 ENTRY(__ashldi3)
+ENTRY(__aeabi_llsl)
 
         subs    r3, r2, #32
         rsb     ip, r2, #32
diff --git a/arch/arm/lib/ashrdi3.S b/arch/arm/lib/ashrdi3.S
index 86fb2a90c301..0b31398f89b2 100644
--- a/arch/arm/lib/ashrdi3.S
+++ b/arch/arm/lib/ashrdi3.S
@@ -37,6 +37,7 @@ Boston, MA 02110-1301, USA.  */
 #endif
 
 ENTRY(__ashrdi3)
+ENTRY(__aeabi_lasr)
 
         subs    r3, r2, #32
         rsb     ip, r2, #32
diff --git a/arch/arm/lib/lib1funcs.S b/arch/arm/lib/lib1funcs.S
index 59026029d017..4e492f4b3f0e 100644
--- a/arch/arm/lib/lib1funcs.S
+++ b/arch/arm/lib/lib1funcs.S
@@ -206,6 +206,7 @@ Boston, MA 02111-1307, USA.  */
 
 
 ENTRY(__udivsi3)
+ENTRY(__aeabi_uidiv)
 
         subs    r2, r1, #1
         moveq   pc, lr
@@ -246,6 +247,7 @@ ENTRY(__umodsi3)
 
 
 ENTRY(__divsi3)
+ENTRY(__aeabi_idiv)
 
         cmp     r1, #0
         eor     ip, r0, r1                      @ save the sign of the result.
@@ -303,12 +305,33 @@ ENTRY(__modsi3)
         rsbmi   r0, r0, #0
         mov     pc, lr
 
+#ifdef CONFIG_AEABI
+
+ENTRY(__aeabi_uidivmod)
+
+        stmfd   sp!, {r0, r1, ip, lr}
+        bl      __aeabi_uidiv
+        ldmfd   sp!, {r1, r2, ip, lr}
+        mul     r3, r0, r2
+        sub     r1, r1, r3
+        mov     pc, lr
+
+ENTRY(__aeabi_idivmod)
+
+        stmfd   sp!, {r0, r1, ip, lr}
+        bl      __aeabi_idiv
+        ldmfd   sp!, {r1, r2, ip, lr}
+        mul     r3, r0, r2
+        sub     r1, r1, r3
+        mov     pc, lr
+
+#endif
 
 Ldiv0:
 
-        str     lr, [sp, #-4]!
+        str     lr, [sp, #-8]!
         bl      __div0
         mov     r0, #0                  @ About as wrong as it could be.
-        ldr     pc, [sp], #4
+        ldr     pc, [sp], #8
 
 
diff --git a/arch/arm/lib/lshrdi3.S b/arch/arm/lib/lshrdi3.S
index 46c2ed19ec95..a86dbdd59cc4 100644
--- a/arch/arm/lib/lshrdi3.S
+++ b/arch/arm/lib/lshrdi3.S
@@ -37,6 +37,7 @@ Boston, MA 02110-1301, USA.  */
 #endif
 
 ENTRY(__lshrdi3)
+ENTRY(__aeabi_llsr)
 
         subs    r3, r2, #32
         rsb     ip, r2, #32
diff --git a/arch/arm/lib/muldi3.S b/arch/arm/lib/muldi3.S
index c7fbdf005319..72d594184b8a 100644
--- a/arch/arm/lib/muldi3.S
+++ b/arch/arm/lib/muldi3.S
@@ -25,6 +25,7 @@
 #endif
 
 ENTRY(__muldi3)
+ENTRY(__aeabi_lmul)
 
         mul     xh, yl, xh
         mla     xh, xl, yh, xh
diff --git a/arch/arm/lib/ucmpdi2.S b/arch/arm/lib/ucmpdi2.S
index 112630f93e5d..d847a62834cb 100644
--- a/arch/arm/lib/ucmpdi2.S
+++ b/arch/arm/lib/ucmpdi2.S
@@ -10,6 +10,7 @@
  *  published by the Free Software Foundation.
  */
 
+#include <linux/config.h>
 #include <linux/linkage.h>
 
 #ifdef __ARMEB__
@@ -33,3 +34,16 @@ ENTRY(__ucmpdi2)
         movhi   r0, #2
         mov     pc, lr
 
+#ifdef CONFIG_AEABI
+
+ENTRY(__aeabi_ulcmp)
+
+        cmp     xh, yh
+        cmpeq   xl, yl
+        movlo   r0, #-1
+        moveq   r0, #0
+        movhi   r0, #1
+        mov     pc, lr
+
+#endif
+
diff --git a/arch/arm/mach-aaec2000/aaed2000.c b/arch/arm/mach-aaec2000/aaed2000.c
index f5ef69702296..dc5fa8e5ebef 100644
--- a/arch/arm/mach-aaec2000/aaed2000.c
+++ b/arch/arm/mach-aaec2000/aaed2000.c
@@ -90,7 +90,6 @@ static void __init aaed2000_map_io(void)
 
 MACHINE_START(AAED2000, "Agilent AAED-2000 Development Platform")
         /* Maintainer: Nicolas Bellido Y Ortega */
-        .phys_ram       = 0xf0000000,
         .phys_io        = PIO_BASE,
         .io_pg_offst    = ((VIO_BASE) >> 18) & 0xfffc,
         .map_io         = aaed2000_map_io,
diff --git a/arch/arm/mach-at91rm9200/board-csb337.c b/arch/arm/mach-at91rm9200/board-csb337.c
index 4aec834ee47f..54022e58d50d 100644
--- a/arch/arm/mach-at91rm9200/board-csb337.c
+++ b/arch/arm/mach-at91rm9200/board-csb337.c
@@ -132,7 +132,6 @@ static void __init csb337_board_init(void)
 
 MACHINE_START(CSB337, "Cogent CSB337")
         /* Maintainer: Bill Gatliff */
-        .phys_ram       = AT91_SDRAM_BASE,
         .phys_io        = AT91_BASE_SYS,
         .io_pg_offst    = (AT91_VA_BASE_SYS >> 18) & 0xfffc,
         .boot_params    = AT91_SDRAM_BASE + 0x100,
diff --git a/arch/arm/mach-at91rm9200/board-csb637.c b/arch/arm/mach-at91rm9200/board-csb637.c
index 23e4cc21481a..8195f9d919ea 100644
--- a/arch/arm/mach-at91rm9200/board-csb637.c
+++ b/arch/arm/mach-at91rm9200/board-csb637.c
@@ -105,7 +105,6 @@ static void __init csb637_board_init(void)
 
 MACHINE_START(CSB637, "Cogent CSB637")
         /* Maintainer: Bill Gatliff */
-        .phys_ram       = AT91_SDRAM_BASE,
         .phys_io        = AT91_BASE_SYS,
         .io_pg_offst    = (AT91_VA_BASE_SYS >> 18) & 0xfffc,
         .boot_params    = AT91_SDRAM_BASE + 0x100,
diff --git a/arch/arm/mach-at91rm9200/board-dk.c b/arch/arm/mach-at91rm9200/board-dk.c
index 8c747a31b95a..8a783368366e 100644
--- a/arch/arm/mach-at91rm9200/board-dk.c
+++ b/arch/arm/mach-at91rm9200/board-dk.c
@@ -127,7 +127,6 @@ static void __init dk_board_init(void)
 
 MACHINE_START(AT91RM9200DK, "Atmel AT91RM9200-DK")
         /* Maintainer: SAN People/Atmel */
-        .phys_ram       = AT91_SDRAM_BASE,
         .phys_io        = AT91_BASE_SYS,
         .io_pg_offst    = (AT91_VA_BASE_SYS >> 18) & 0xfffc,
         .boot_params    = AT91_SDRAM_BASE + 0x100,
diff --git a/arch/arm/mach-at91rm9200/board-ek.c b/arch/arm/mach-at91rm9200/board-ek.c
index d140645711be..fd0752eba897 100644
--- a/arch/arm/mach-at91rm9200/board-ek.c
+++ b/arch/arm/mach-at91rm9200/board-ek.c
@@ -120,7 +120,6 @@ static void __init ek_board_init(void)
 
 MACHINE_START(AT91RM9200EK, "Atmel AT91RM9200-EK")
         /* Maintainer: SAN People/Atmel */
-        .phys_ram       = AT91_SDRAM_BASE,
         .phys_io        = AT91_BASE_SYS,
         .io_pg_offst    = (AT91_VA_BASE_SYS >> 18) & 0xfffc,
         .boot_params    = AT91_SDRAM_BASE + 0x100,
diff --git a/arch/arm/mach-clps711x/autcpu12.c b/arch/arm/mach-clps711x/autcpu12.c
index 43b9423d1440..c13ca6c56baa 100644
--- a/arch/arm/mach-clps711x/autcpu12.c
+++ b/arch/arm/mach-clps711x/autcpu12.c
@@ -64,7 +64,6 @@ void __init autcpu12_map_io(void)
 
 MACHINE_START(AUTCPU12, "autronix autcpu12")
         /* Maintainer: Thomas Gleixner */
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xff000000) >> 18) & 0xfffc,
         .boot_params    = 0xc0020000,
diff --git a/arch/arm/mach-clps711x/cdb89712.c b/arch/arm/mach-clps711x/cdb89712.c
index cba7be5a06c3..831df007f6c7 100644
--- a/arch/arm/mach-clps711x/cdb89712.c
+++ b/arch/arm/mach-clps711x/cdb89712.c
@@ -55,7 +55,6 @@ static void __init cdb89712_map_io(void)
 
 MACHINE_START(CDB89712, "Cirrus-CDB89712")
         /* Maintainer: Ray Lehtiniemi */
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xff000000) >> 18) & 0xfffc,
         .boot_params    = 0xc0000100,
diff --git a/arch/arm/mach-clps711x/ceiva.c b/arch/arm/mach-clps711x/ceiva.c
index 35d51a759b59..e2b2c5ac8a83 100644
--- a/arch/arm/mach-clps711x/ceiva.c
+++ b/arch/arm/mach-clps711x/ceiva.c
@@ -56,7 +56,6 @@ static void __init ceiva_map_io(void)
 
 MACHINE_START(CEIVA, "CEIVA/Polaroid Photo MAX Digital Picture Frame")
         /* Maintainer: Rob Scott */
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xff000000) >> 18) & 0xfffc,
         .boot_params    = 0xc0000100,
diff --git a/arch/arm/mach-clps711x/clep7312.c b/arch/arm/mach-clps711x/clep7312.c
index c83f3fd68fcd..09fb57e45213 100644
--- a/arch/arm/mach-clps711x/clep7312.c
+++ b/arch/arm/mach-clps711x/clep7312.c
@@ -38,7 +38,6 @@ fixup_clep7312(struct machine_desc *desc, struct tag *tags,
 
 MACHINE_START(CLEP7212, "Cirrus Logic 7212/7312")
         /* Maintainer: Nobody */
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xff000000) >> 18) & 0xfffc,
         .boot_params    = 0xc0000100,
diff --git a/arch/arm/mach-clps711x/edb7211-arch.c b/arch/arm/mach-clps711x/edb7211-arch.c
index 255c98b63e15..dc81cc68595d 100644
--- a/arch/arm/mach-clps711x/edb7211-arch.c
+++ b/arch/arm/mach-clps711x/edb7211-arch.c
@@ -52,7 +52,6 @@ fixup_edb7211(struct machine_desc *desc, struct tag *tags,
 
 MACHINE_START(EDB7211, "CL-EDB7211 (EP7211 eval board)")
         /* Maintainer: Jon McClintock */
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xff000000) >> 18) & 0xfffc,
         .boot_params    = 0xc0020100,   /* 0xc0000000 - 0xc001ffff can be video RAM */
diff --git a/arch/arm/mach-clps711x/fortunet.c b/arch/arm/mach-clps711x/fortunet.c
index 3d88da0c287b..ff26a85aa4ba 100644
--- a/arch/arm/mach-clps711x/fortunet.c
+++ b/arch/arm/mach-clps711x/fortunet.c
@@ -78,7 +78,6 @@ fortunet_fixup(struct machine_desc *desc, struct tag *tags,
 
 MACHINE_START(FORTUNET, "ARM-FortuNet")
         /* Maintainer: FortuNet Inc. */
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xf0000000) >> 18) & 0xfffc,
         .boot_params    = 0x00000000,
diff --git a/arch/arm/mach-clps711x/p720t.c b/arch/arm/mach-clps711x/p720t.c
index a1acb945fb51..9ba45f4d5a7e 100644
--- a/arch/arm/mach-clps711x/p720t.c
+++ b/arch/arm/mach-clps711x/p720t.c
@@ -90,7 +90,6 @@ static void __init p720t_map_io(void)
 
 MACHINE_START(P720T, "ARM-Prospector720T")
         /* Maintainer: ARM Ltd/Deep Blue Solutions Ltd */
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xff000000) >> 18) & 0xfffc,
         .boot_params    = 0xc0000100,
diff --git a/arch/arm/mach-clps7500/core.c b/arch/arm/mach-clps7500/core.c
index d869af0023f8..5b12cab0e691 100644
--- a/arch/arm/mach-clps7500/core.c
+++ b/arch/arm/mach-clps7500/core.c
@@ -384,7 +384,6 @@ static void __init clps7500_init(void)
 
 MACHINE_START(CLPS7500, "CL-PS7500")
         /* Maintainer: Philip Blundell */
-        .phys_ram       = 0x10000000,
         .phys_io        = 0x03000000,
         .io_pg_offst    = ((0xe0000000) >> 18) & 0xfffc,
         .map_io         = clps7500_map_io,
diff --git a/arch/arm/mach-ebsa110/core.c b/arch/arm/mach-ebsa110/core.c
index ed4614983adb..6d620d8268cc 100644
--- a/arch/arm/mach-ebsa110/core.c
+++ b/arch/arm/mach-ebsa110/core.c
@@ -284,7 +284,6 @@ arch_initcall(ebsa110_init);
 
 MACHINE_START(EBSA110, "EBSA110")
         /* Maintainer: Russell King */
-        .phys_ram       = 0x00000000,
         .phys_io        = 0xe0000000,
         .io_pg_offst    = ((0xe0000000) >> 18) & 0xfffc,
         .boot_params    = 0x00000400,
diff --git a/arch/arm/mach-footbridge/cats-hw.c b/arch/arm/mach-footbridge/cats-hw.c
index 49b898af0032..5b64d5c5b967 100644
--- a/arch/arm/mach-footbridge/cats-hw.c
+++ b/arch/arm/mach-footbridge/cats-hw.c
@@ -85,7 +85,6 @@ fixup_cats(struct machine_desc *desc, struct tag *tags,
 
 MACHINE_START(CATS, "Chalice-CATS")
         /* Maintainer: Philip Blundell */
-        .phys_ram       = 0x00000000,
         .phys_io        = DC21285_ARMCSR_BASE,
         .io_pg_offst    = ((0xfe000000) >> 18) & 0xfffc,
         .boot_params    = 0x00000100,
diff --git a/arch/arm/mach-footbridge/co285.c b/arch/arm/mach-footbridge/co285.c
index 548a79081688..4545576ad8d9 100644
--- a/arch/arm/mach-footbridge/co285.c
+++ b/arch/arm/mach-footbridge/co285.c
@@ -29,7 +29,6 @@ fixup_coebsa285(struct machine_desc *desc, struct tag *tags,
 
 MACHINE_START(CO285, "co-EBSA285")
         /* Maintainer: Mark van Doesburg */
-        .phys_ram       = 0x00000000,
         .phys_io        = DC21285_ARMCSR_BASE,
         .io_pg_offst    = ((0x7cf00000) >> 18) & 0xfffc,
         .fixup          = fixup_coebsa285,
diff --git a/arch/arm/mach-footbridge/ebsa285.c b/arch/arm/mach-footbridge/ebsa285.c
index 1c37605268d5..b1d3bf20a41e 100644
--- a/arch/arm/mach-footbridge/ebsa285.c
+++ b/arch/arm/mach-footbridge/ebsa285.c
@@ -14,7 +14,6 @@
 
 MACHINE_START(EBSA285, "EBSA285")
         /* Maintainer: Russell King */
-        .phys_ram       = 0x00000000,
         .phys_io        = DC21285_ARMCSR_BASE,
         .io_pg_offst    = ((0xfe000000) >> 18) & 0xfffc,
         .boot_params    = 0x00000100,
diff --git a/arch/arm/mach-footbridge/netwinder-hw.c b/arch/arm/mach-footbridge/netwinder-hw.c
index 9e563de465b5..229bf0585e40 100644
--- a/arch/arm/mach-footbridge/netwinder-hw.c
+++ b/arch/arm/mach-footbridge/netwinder-hw.c
@@ -649,7 +649,6 @@ fixup_netwinder(struct machine_desc *desc, struct tag *tags,
 
 MACHINE_START(NETWINDER, "Rebel-NetWinder")
         /* Maintainer: Russell King/Rebel.com */
-        .phys_ram       = 0x00000000,
         .phys_io        = DC21285_ARMCSR_BASE,
         .io_pg_offst    = ((0xfe000000) >> 18) & 0xfffc,
         .boot_params    = 0x00000100,
diff --git a/arch/arm/mach-footbridge/personal.c b/arch/arm/mach-footbridge/personal.c
index 0146b8bb59da..c4f843fc099d 100644
--- a/arch/arm/mach-footbridge/personal.c
+++ b/arch/arm/mach-footbridge/personal.c
@@ -14,7 +14,6 @@
 
 MACHINE_START(PERSONAL_SERVER, "Compaq-PersonalServer")
         /* Maintainer: Jamey Hicks / George France */
-        .phys_ram       = 0x00000000,
         .phys_io        = DC21285_ARMCSR_BASE,
         .io_pg_offst    = ((0xfe000000) >> 18) & 0xfffc,
         .boot_params    = 0x00000100,
diff --git a/arch/arm/mach-h720x/h7201-eval.c b/arch/arm/mach-h720x/h7201-eval.c
index fa59e9e2a5c8..193f968edac3 100644
--- a/arch/arm/mach-h720x/h7201-eval.c
+++ b/arch/arm/mach-h720x/h7201-eval.c
@@ -31,7 +31,6 @@
 
 MACHINE_START(H7201, "Hynix GMS30C7201")
         /* Maintainer: Robert Schwebel, Pengutronix */
-        .phys_ram       = 0x40000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xf0000000) >> 18) & 0xfffc,
         .boot_params    = 0xc0001000,
diff --git a/arch/arm/mach-h720x/h7202-eval.c b/arch/arm/mach-h720x/h7202-eval.c
index d75c8221d2a5..36266896979c 100644
--- a/arch/arm/mach-h720x/h7202-eval.c
+++ b/arch/arm/mach-h720x/h7202-eval.c
@@ -72,7 +72,6 @@ static void __init init_eval_h7202(void)
 
 MACHINE_START(H7202, "Hynix HMS30C7202")
         /* Maintainer: Robert Schwebel, Pengutronix */
-        .phys_ram       = 0x40000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xf0000000) >> 18) & 0xfffc,
         .boot_params    = 0x40000100,
diff --git a/arch/arm/mach-imx/mx1ads.c b/arch/arm/mach-imx/mx1ads.c
index c9e0cd8ed016..dc31e3fd6c57 100644
--- a/arch/arm/mach-imx/mx1ads.c
+++ b/arch/arm/mach-imx/mx1ads.c
@@ -69,7 +69,6 @@ mx1ads_map_io(void)
 
 MACHINE_START(MX1ADS, "Motorola MX1ADS")
         /* Maintainer: Sascha Hauer, Pengutronix */
-        .phys_ram       = 0x08000000,
         .phys_io        = 0x00200000,
         .io_pg_offst    = ((0xe0200000) >> 18) & 0xfffc,
         .boot_params    = 0x08000100,
diff --git a/arch/arm/mach-integrator/integrator_ap.c b/arch/arm/mach-integrator/integrator_ap.c
index 3afedeb56a6e..d8d3c2a5a97e 100644
--- a/arch/arm/mach-integrator/integrator_ap.c
+++ b/arch/arm/mach-integrator/integrator_ap.c
@@ -347,7 +347,6 @@ static struct sys_timer ap_timer = {
 
 MACHINE_START(INTEGRATOR, "ARM-Integrator")
         /* Maintainer: ARM Ltd/Deep Blue Solutions Ltd */
-        .phys_ram       = 0x00000000,
         .phys_io        = 0x16000000,
         .io_pg_offst    = ((0xf1600000) >> 18) & 0xfffc,
         .boot_params    = 0x00000100,
diff --git a/arch/arm/mach-integrator/integrator_cp.c b/arch/arm/mach-integrator/integrator_cp.c
index 16cf2482a3e9..31820170f306 100644
--- a/arch/arm/mach-integrator/integrator_cp.c
+++ b/arch/arm/mach-integrator/integrator_cp.c
@@ -578,7 +578,6 @@ static struct sys_timer cp_timer = {
 
 MACHINE_START(CINTEGRATOR, "ARM-IntegratorCP")
         /* Maintainer: ARM Ltd/Deep Blue Solutions Ltd */
-        .phys_ram       = 0x00000000,
         .phys_io        = 0x16000000,
         .io_pg_offst    = ((0xf1600000) >> 18) & 0xfffc,
         .boot_params    = 0x00000100,
diff --git a/arch/arm/mach-integrator/lm.c b/arch/arm/mach-integrator/lm.c
index 5b41e3a724e1..622cdc4212dd 100644
--- a/arch/arm/mach-integrator/lm.c
+++ b/arch/arm/mach-integrator/lm.c
@@ -22,20 +22,6 @@ static int lm_match(struct device *dev, struct device_driver *drv)
         return 1;
 }
 
-static struct bus_type lm_bustype = {
-        .name           = "logicmodule",
-        .match          = lm_match,
-//      .suspend        = lm_suspend,
-//      .resume         = lm_resume,
-};
-
-static int __init lm_init(void)
-{
-        return bus_register(&lm_bustype);
-}
-
-postcore_initcall(lm_init);
-
 static int lm_bus_probe(struct device *dev)
 {
         struct lm_device *lmdev = to_lm_device(dev);
@@ -49,16 +35,30 @@ static int lm_bus_remove(struct device *dev)
         struct lm_device *lmdev = to_lm_device(dev);
         struct lm_driver *lmdrv = to_lm_driver(dev->driver);
 
-        lmdrv->remove(lmdev);
+        if (lmdrv->remove)
+                lmdrv->remove(lmdev);
         return 0;
 }
 
+static struct bus_type lm_bustype = {
+        .name           = "logicmodule",
+        .match          = lm_match,
+        .probe          = lm_bus_probe,
+        .remove         = lm_bus_remove,
+//      .suspend        = lm_bus_suspend,
+//      .resume         = lm_bus_resume,
+};
+
+static int __init lm_init(void)
+{
+        return bus_register(&lm_bustype);
+}
+
+postcore_initcall(lm_init);
+
 int lm_driver_register(struct lm_driver *drv)
 {
         drv->drv.bus = &lm_bustype;
-        drv->drv.probe = lm_bus_probe;
-        drv->drv.remove = lm_bus_remove;
-
         return driver_register(&drv->drv);
 }
 
diff --git a/arch/arm/mach-iop3xx/iop321-setup.c b/arch/arm/mach-iop3xx/iop321-setup.c
index 80770233b8d4..e4f4c52d93d4 100644
--- a/arch/arm/mach-iop3xx/iop321-setup.c
+++ b/arch/arm/mach-iop3xx/iop321-setup.c
@@ -151,7 +151,6 @@ extern void iop321_init_time(void);
 #if defined(CONFIG_ARCH_IQ80321)
 MACHINE_START(IQ80321, "Intel IQ80321")
         /* Maintainer: Intel Corporation */
-        .phys_ram       = PHYS_OFFSET,
         .phys_io        = IQ80321_UART,
         .io_pg_offst    = ((IQ80321_UART) >> 18) & 0xfffc,
         .map_io         = iq80321_map_io,
@@ -163,7 +162,6 @@ MACHINE_END
 #elif defined(CONFIG_ARCH_IQ31244)
 MACHINE_START(IQ31244, "Intel IQ31244")
         /* Maintainer: Intel Corp. */
-        .phys_ram       = PHYS_OFFSET,
         .phys_io        = IQ31244_UART,
         .io_pg_offst    = ((IQ31244_UART) >> 18) & 0xfffc,
         .map_io         = iq31244_map_io,
diff --git a/arch/arm/mach-iop3xx/iop331-setup.c b/arch/arm/mach-iop3xx/iop331-setup.c
index e6ea1cba6a17..63585485123e 100644
--- a/arch/arm/mach-iop3xx/iop331-setup.c
+++ b/arch/arm/mach-iop3xx/iop331-setup.c
@@ -195,7 +195,6 @@ extern void iq80332_map_io(void);
 #if defined(CONFIG_ARCH_IQ80331)
 MACHINE_START(IQ80331, "Intel IQ80331")
         /* Maintainer: Intel Corp. */
-        .phys_ram       = PHYS_OFFSET,
         .phys_io        = 0xfefff000,
         .io_pg_offst    = ((0xfffff000) >> 18) & 0xfffc, // virtual, physical
         .map_io         = iq80331_map_io,
@@ -208,7 +207,6 @@ MACHINE_END
 #elif defined(CONFIG_MACH_IQ80332)
 MACHINE_START(IQ80332, "Intel IQ80332")
         /* Maintainer: Intel Corp. */
-        .phys_ram       = PHYS_OFFSET,
         .phys_io        = 0xfefff000,
         .io_pg_offst    = ((0xfffff000) >> 18) & 0xfffc, // virtual, physical
         .map_io         = iq80332_map_io,
diff --git a/arch/arm/mach-ixp2000/core.c b/arch/arm/mach-ixp2000/core.c
index 6851abaf5524..cfd5bef3190b 100644
--- a/arch/arm/mach-ixp2000/core.c
+++ b/arch/arm/mach-ixp2000/core.c
@@ -106,6 +106,16 @@ static struct map_desc ixp2000_io_desc[] __initdata = {
                 .length         = IXP2000_MSF_SIZE,
                 .type           = MT_IXP2000_DEVICE,
         }, {
+                .virtual        = IXP2000_SCRATCH_RING_VIRT_BASE,
+                .pfn            = __phys_to_pfn(IXP2000_SCRATCH_RING_PHYS_BASE),
+                .length         = IXP2000_SCRATCH_RING_SIZE,
+                .type           = MT_IXP2000_DEVICE,
+        }, {
+                .virtual        = IXP2000_SRAM0_VIRT_BASE,
+                .pfn            = __phys_to_pfn(IXP2000_SRAM0_PHYS_BASE),
+                .length         = IXP2000_SRAM0_SIZE,
+                .type           = MT_IXP2000_DEVICE,
+        }, {
                 .virtual        = IXP2000_PCI_IO_VIRT_BASE,
                 .pfn            = __phys_to_pfn(IXP2000_PCI_IO_PHYS_BASE),
                 .length         = IXP2000_PCI_IO_SIZE,
diff --git a/arch/arm/mach-ixp2000/enp2611.c b/arch/arm/mach-ixp2000/enp2611.c
index 61f6006241bd..9e5a13bb39d0 100644
--- a/arch/arm/mach-ixp2000/enp2611.c
+++ b/arch/arm/mach-ixp2000/enp2611.c
@@ -254,7 +254,6 @@ static void __init enp2611_init_machine(void)
 
 MACHINE_START(ENP2611, "Radisys ENP-2611 PCI network processor board")
         /* Maintainer: Lennert Buytenhek <buytenh@wantstofly.org> */
-        .phys_ram       = 0x00000000,
         .phys_io        = IXP2000_UART_PHYS_BASE,
         .io_pg_offst    = ((IXP2000_UART_VIRT_BASE) >> 18) & 0xfffc,
         .boot_params    = 0x00000100,
diff --git a/arch/arm/mach-ixp2000/ixdp2400.c b/arch/arm/mach-ixp2000/ixdp2400.c
index fd280a93637e..7c782403042a 100644
--- a/arch/arm/mach-ixp2000/ixdp2400.c
+++ b/arch/arm/mach-ixp2000/ixdp2400.c
@@ -169,7 +169,6 @@ void ixdp2400_init_irq(void)
 
 MACHINE_START(IXDP2400, "Intel IXDP2400 Development Platform")
         /* Maintainer: MontaVista Software, Inc. */
-        .phys_ram       = 0x00000000,
         .phys_io        = IXP2000_UART_PHYS_BASE,
         .io_pg_offst    = ((IXP2000_UART_VIRT_BASE) >> 18) & 0xfffc,
         .boot_params    = 0x00000100,
diff --git a/arch/arm/mach-ixp2000/ixdp2800.c b/arch/arm/mach-ixp2000/ixdp2800.c
index f9073aa28615..076e3f8acc96 100644
--- a/arch/arm/mach-ixp2000/ixdp2800.c
+++ b/arch/arm/mach-ixp2000/ixdp2800.c
@@ -285,7 +285,6 @@ void ixdp2800_init_irq(void)
 
 MACHINE_START(IXDP2800, "Intel IXDP2800 Development Platform")
         /* Maintainer: MontaVista Software, Inc. */
-        .phys_ram       = 0x00000000,
         .phys_io        = IXP2000_UART_PHYS_BASE,
         .io_pg_offst    = ((IXP2000_UART_VIRT_BASE) >> 18) & 0xfffc,
         .boot_params    = 0x00000100,
diff --git a/arch/arm/mach-ixp2000/ixdp2x01.c b/arch/arm/mach-ixp2000/ixdp2x01.c
index e6a882f35da2..10f06606d460 100644
--- a/arch/arm/mach-ixp2000/ixdp2x01.c
+++ b/arch/arm/mach-ixp2000/ixdp2x01.c
@@ -376,7 +376,6 @@ static void __init ixdp2x01_init_machine(void)
 #ifdef CONFIG_ARCH_IXDP2401
 MACHINE_START(IXDP2401, "Intel IXDP2401 Development Platform")
         /* Maintainer: MontaVista Software, Inc. */
-        .phys_ram       = 0x00000000,
         .phys_io        = IXP2000_UART_PHYS_BASE,
         .io_pg_offst    = ((IXP2000_UART_VIRT_BASE) >> 18) & 0xfffc,
         .boot_params    = 0x00000100,
@@ -390,7 +389,6 @@ MACHINE_END
 #ifdef CONFIG_ARCH_IXDP2801
 MACHINE_START(IXDP2801, "Intel IXDP2801 Development Platform")
         /* Maintainer: MontaVista Software, Inc. */
-        .phys_ram       = 0x00000000,
         .phys_io        = IXP2000_UART_PHYS_BASE,
         .io_pg_offst    = ((IXP2000_UART_VIRT_BASE) >> 18) & 0xfffc,
         .boot_params    = 0x00000100,
diff --git a/arch/arm/mach-ixp4xx/coyote-setup.c b/arch/arm/mach-ixp4xx/coyote-setup.c
index 679594a73981..13f8a7ac3ba9 100644
--- a/arch/arm/mach-ixp4xx/coyote-setup.c
+++ b/arch/arm/mach-ixp4xx/coyote-setup.c
@@ -101,7 +101,6 @@ static void __init coyote_init(void)
 #ifdef CONFIG_ARCH_ADI_COYOTE
 MACHINE_START(ADI_COYOTE, "ADI Engineering Coyote")
         /* Maintainer: MontaVista Software, Inc. */
-        .phys_ram       = PHYS_OFFSET,
         .phys_io        = IXP4XX_PERIPHERAL_BASE_PHYS,
         .io_pg_offst    = ((IXP4XX_PERIPHERAL_BASE_VIRT) >> 18) & 0xfffc,
         .map_io         = ixp4xx_map_io,
@@ -119,7 +118,6 @@ MACHINE_END
 #ifdef CONFIG_MACH_IXDPG425
 MACHINE_START(IXDPG425, "Intel IXDPG425")
         /* Maintainer: MontaVista Software, Inc. */
-        .phys_ram       = PHYS_OFFSET,
         .phys_io        = IXP4XX_PERIPHERAL_BASE_PHYS,
         .io_pg_offst    = ((IXP4XX_PERIPHERAL_BASE_VIRT) >> 18) & 0xfffc,
         .map_io         = ixp4xx_map_io,
diff --git a/arch/arm/mach-ixp4xx/gtwx5715-setup.c b/arch/arm/mach-ixp4xx/gtwx5715-setup.c
index 038670489970..654e2eed81fb 100644
--- a/arch/arm/mach-ixp4xx/gtwx5715-setup.c
+++ b/arch/arm/mach-ixp4xx/gtwx5715-setup.c
@@ -142,7 +142,6 @@ static void __init gtwx5715_init(void)
 
 MACHINE_START(GTWX5715, "Gemtek GTWX5715 (Linksys WRV54G)")
         /* Maintainer: George Joseph */
-        .phys_ram       = PHYS_OFFSET,
         .phys_io        = IXP4XX_UART2_BASE_PHYS,
         .io_pg_offst    = ((IXP4XX_UART2_BASE_VIRT) >> 18) & 0xfffc,
         .map_io         = ixp4xx_map_io,
diff --git a/arch/arm/mach-ixp4xx/ixdp425-setup.c b/arch/arm/mach-ixp4xx/ixdp425-setup.c
index c2e105c89c95..da72383ee301 100644
--- a/arch/arm/mach-ixp4xx/ixdp425-setup.c
+++ b/arch/arm/mach-ixp4xx/ixdp425-setup.c
@@ -121,7 +121,6 @@ static void __init ixdp425_init(void)
 #ifdef CONFIG_ARCH_IXDP425
 MACHINE_START(IXDP425, "Intel IXDP425 Development Platform")
         /* Maintainer: MontaVista Software, Inc. */
-        .phys_ram       = PHYS_OFFSET,
         .phys_io        = IXP4XX_PERIPHERAL_BASE_PHYS,
         .io_pg_offst    = ((IXP4XX_PERIPHERAL_BASE_VIRT) >> 18) & 0xfffc,
         .map_io         = ixp4xx_map_io,
@@ -135,7 +134,6 @@ MACHINE_END
 #ifdef CONFIG_MACH_IXDP465
 MACHINE_START(IXDP465, "Intel IXDP465 Development Platform")
         /* Maintainer: MontaVista Software, Inc. */
-        .phys_ram       = PHYS_OFFSET,
         .phys_io        = IXP4XX_PERIPHERAL_BASE_PHYS,
         .io_pg_offst    = ((IXP4XX_PERIPHERAL_BASE_VIRT) >> 18) & 0xfffc,
         .map_io         = ixp4xx_map_io,
@@ -149,7 +147,6 @@ MACHINE_END
 #ifdef CONFIG_ARCH_PRPMC1100
 MACHINE_START(IXCDP1100, "Intel IXCDP1100 Development Platform")
         /* Maintainer: MontaVista Software, Inc. */
-        .phys_ram       = PHYS_OFFSET,
         .phys_io        = IXP4XX_PERIPHERAL_BASE_PHYS,
         .io_pg_offst    = ((IXP4XX_PERIPHERAL_BASE_VIRT) >> 18) & 0xfffc,
         .map_io         = ixp4xx_map_io,
@@ -169,7 +166,6 @@ MACHINE_END
 #ifdef CONFIG_ARCH_AVILA
 MACHINE_START(AVILA, "Gateworks Avila Network Platform")
         /* Maintainer: Deepak Saxena <dsaxena@plexity.net> */
-        .phys_ram       = PHYS_OFFSET,
         .phys_io        = IXP4XX_PERIPHERAL_BASE_PHYS,
         .io_pg_offst    = ((IXP4XX_PERIPHERAL_BASE_VIRT) >> 18) & 0xfffc,
         .map_io         = ixp4xx_map_io,
diff --git a/arch/arm/mach-ixp4xx/nas100d-setup.c b/arch/arm/mach-ixp4xx/nas100d-setup.c
index 49998a8bd4e8..856d56f3b2ae 100644
--- a/arch/arm/mach-ixp4xx/nas100d-setup.c
+++ b/arch/arm/mach-ixp4xx/nas100d-setup.c
@@ -124,7 +124,6 @@ static void __init nas100d_init(void)
 
 MACHINE_START(NAS100D, "Iomega NAS 100d")
         /* Maintainer: www.nslu2-linux.org */
-        .phys_ram       = PHYS_OFFSET,
         .phys_io        = IXP4XX_PERIPHERAL_BASE_PHYS,
         .io_pg_offst    = ((IXP4XX_PERIPHERAL_BASE_VIRT) >> 18) & 0xFFFC,
         .boot_params    = 0x00000100,
diff --git a/arch/arm/mach-ixp4xx/nslu2-setup.c b/arch/arm/mach-ixp4xx/nslu2-setup.c
index 289e94cb65c2..da9340a53434 100644
--- a/arch/arm/mach-ixp4xx/nslu2-setup.c
+++ b/arch/arm/mach-ixp4xx/nslu2-setup.c
@@ -123,7 +123,6 @@ static void __init nslu2_init(void)
 
 MACHINE_START(NSLU2, "Linksys NSLU2")
         /* Maintainer: www.nslu2-linux.org */
-        .phys_ram       = PHYS_OFFSET,
         .phys_io        = IXP4XX_PERIPHERAL_BASE_PHYS,
         .io_pg_offst    = ((IXP4XX_PERIPHERAL_BASE_VIRT) >> 18) & 0xFFFC,
         .boot_params    = 0x00000100,
diff --git a/arch/arm/mach-l7200/core.c b/arch/arm/mach-l7200/core.c
index 03ed742ae2be..ac626436e96f 100644
--- a/arch/arm/mach-l7200/core.c
+++ b/arch/arm/mach-l7200/core.c
@@ -91,7 +91,6 @@ static void __init l7200_map_io(void)
 
 MACHINE_START(L7200, "LinkUp Systems L7200")
         /* Maintainer: Steve Hill / Scott McConnell */
-        .phys_ram       = 0xf0000000,
         .phys_io        = 0x80040000,
         .io_pg_offst    = ((0xd0000000) >> 18) & 0xfffc,
         .map_io         = l7200_map_io,
diff --git a/arch/arm/mach-lh7a40x/arch-kev7a400.c b/arch/arm/mach-lh7a40x/arch-kev7a400.c
index 19f2fa2244c4..2cccc27c62e4 100644
--- a/arch/arm/mach-lh7a40x/arch-kev7a400.c
+++ b/arch/arm/mach-lh7a40x/arch-kev7a400.c
@@ -112,7 +112,6 @@ void __init lh7a40x_init_board_irq (void)
 
 MACHINE_START (KEV7A400, "Sharp KEV7a400")
         /* Maintainer: Marc Singer */
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((io_p2v (0x80000000))>>18) & 0xfffc,
         .boot_params    = 0xc0000100,
diff --git a/arch/arm/mach-lh7a40x/arch-lpd7a40x.c b/arch/arm/mach-lh7a40x/arch-lpd7a40x.c
index 4eb962fdb3a8..12e23277c5ea 100644
--- a/arch/arm/mach-lh7a40x/arch-lpd7a40x.c
+++ b/arch/arm/mach-lh7a40x/arch-lpd7a40x.c
@@ -317,7 +317,6 @@ lpd7a400_map_io(void)
 
 MACHINE_START (LPD7A400, "Logic Product Development LPD7A400-10")
         /* Maintainer: Marc Singer */
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((io_p2v (0x80000000))>>18) & 0xfffc,
         .boot_params    = 0xc0000100,
@@ -333,7 +332,6 @@ MACHINE_END
 
 MACHINE_START (LPD7A404, "Logic Product Development LPD7A404-10")
         /* Maintainer: Marc Singer */
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((io_p2v (0x80000000))>>18) & 0xfffc,
         .boot_params    = 0xc0000100,
diff --git a/arch/arm/mach-omap1/board-generic.c b/arch/arm/mach-omap1/board-generic.c
index 4b292e93fbe2..bdc20b51b076 100644
--- a/arch/arm/mach-omap1/board-generic.c
+++ b/arch/arm/mach-omap1/board-generic.c
@@ -109,7 +109,6 @@ static void __init omap_generic_map_io(void)
 
 MACHINE_START(OMAP_GENERIC, "Generic OMAP1510/1610/1710")
         /* Maintainer: Tony Lindgren <tony@atomide.com> */
-        .phys_ram       = 0x10000000,
         .phys_io        = 0xfff00000,
         .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
diff --git a/arch/arm/mach-omap1/board-h2.c b/arch/arm/mach-omap1/board-h2.c
index a07e2c9307fa..9533c36a92df 100644
--- a/arch/arm/mach-omap1/board-h2.c
+++ b/arch/arm/mach-omap1/board-h2.c
@@ -199,7 +199,6 @@ static void __init h2_map_io(void)
 
 MACHINE_START(OMAP_H2, "TI-H2")
         /* Maintainer: Imre Deak <imre.deak@nokia.com> */
-        .phys_ram       = 0x10000000,
         .phys_io        = 0xfff00000,
         .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
diff --git a/arch/arm/mach-omap1/board-h3.c b/arch/arm/mach-omap1/board-h3.c
index 668e278433c2..d665efc1c344 100644
--- a/arch/arm/mach-omap1/board-h3.c
+++ b/arch/arm/mach-omap1/board-h3.c
@@ -215,7 +215,6 @@ static void __init h3_map_io(void)
 
 MACHINE_START(OMAP_H3, "TI OMAP1710 H3 board")
         /* Maintainer: Texas Instruments, Inc. */
-        .phys_ram       = 0x10000000,
         .phys_io        = 0xfff00000,
         .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
diff --git a/arch/arm/mach-omap1/board-innovator.c b/arch/arm/mach-omap1/board-innovator.c
index 95f1ff36cdcb..652f37c7f906 100644
--- a/arch/arm/mach-omap1/board-innovator.c
+++ b/arch/arm/mach-omap1/board-innovator.c
@@ -303,7 +303,6 @@ static void __init innovator_map_io(void)
 
 MACHINE_START(OMAP_INNOVATOR, "TI-Innovator")
         /* Maintainer: MontaVista Software, Inc. */
-        .phys_ram       = 0x10000000,
         .phys_io        = 0xfff00000,
         .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
diff --git a/arch/arm/mach-omap1/board-netstar.c b/arch/arm/mach-omap1/board-netstar.c
index 0448fa7de8a4..58f783930d45 100644
--- a/arch/arm/mach-omap1/board-netstar.c
+++ b/arch/arm/mach-omap1/board-netstar.c
@@ -149,7 +149,6 @@ postcore_initcall(netstar_late_init);
 
 MACHINE_START(NETSTAR, "NetStar OMAP5910")
         /* Maintainer: Ladislav Michl <michl@2n.cz> */
-        .phys_ram       = 0x10000000,
         .phys_io        = 0xfff00000,
         .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
diff --git a/arch/arm/mach-omap1/board-osk.c b/arch/arm/mach-omap1/board-osk.c
index e990e1bc1669..e5d126e8f276 100644
--- a/arch/arm/mach-omap1/board-osk.c
+++ b/arch/arm/mach-omap1/board-osk.c
@@ -274,7 +274,6 @@ static void __init osk_map_io(void)
 
 MACHINE_START(OMAP_OSK, "TI-OSK")
         /* Maintainer: Dirk Behme <dirk.behme@de.bosch.com> */
-        .phys_ram       = 0x10000000,
         .phys_io        = 0xfff00000,
         .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
diff --git a/arch/arm/mach-omap1/board-palmte.c b/arch/arm/mach-omap1/board-palmte.c
index 5c975eb5c34b..67fada207622 100644
--- a/arch/arm/mach-omap1/board-palmte.c
+++ b/arch/arm/mach-omap1/board-palmte.c
@@ -76,7 +76,6 @@ static void __init omap_generic_map_io(void)
 }
 
 MACHINE_START(OMAP_PALMTE, "OMAP310 based Palm Tungsten E")
-        .phys_ram       = 0x10000000,
         .phys_io        = 0xfff00000,
         .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
diff --git a/arch/arm/mach-omap1/board-perseus2.c b/arch/arm/mach-omap1/board-perseus2.c
index 92ff5dc07351..88708a0c52a2 100644
--- a/arch/arm/mach-omap1/board-perseus2.c
+++ b/arch/arm/mach-omap1/board-perseus2.c
@@ -199,7 +199,6 @@ static void __init omap_perseus2_map_io(void)
 
 MACHINE_START(OMAP_PERSEUS2, "OMAP730 Perseus2")
         /* Maintainer: Kevin Hilman <kjh@hilman.org> */
-        .phys_ram       = 0x10000000,
         .phys_io        = 0xfff00000,
         .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
diff --git a/arch/arm/mach-omap1/board-voiceblue.c b/arch/arm/mach-omap1/board-voiceblue.c
index 6f9a6220e78a..959b4b847c87 100644
--- a/arch/arm/mach-omap1/board-voiceblue.c
+++ b/arch/arm/mach-omap1/board-voiceblue.c
@@ -281,7 +281,6 @@ EXPORT_SYMBOL(voiceblue_wdt_ping);
 
 MACHINE_START(VOICEBLUE, "VoiceBlue OMAP5910")
         /* Maintainer: Ladislav Michl <michl@2n.cz> */
-        .phys_ram       = 0x10000000,
         .phys_io        = 0xfff00000,
         .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
diff --git a/arch/arm/mach-omap2/board-generic.c b/arch/arm/mach-omap2/board-generic.c
index c602e7a3d93e..b937123e5c65 100644
--- a/arch/arm/mach-omap2/board-generic.c
+++ b/arch/arm/mach-omap2/board-generic.c
@@ -69,7 +69,6 @@ static void __init omap_generic_map_io(void)
 
 MACHINE_START(OMAP_GENERIC, "Generic OMAP24xx")
         /* Maintainer: Paul Mundt <paul.mundt@nokia.com> */
-        .phys_ram       = 0x80000000,
         .phys_io        = 0x48000000,
         .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
diff --git a/arch/arm/mach-omap2/board-h4.c b/arch/arm/mach-omap2/board-h4.c
index f2554469a76a..c3c35d40378a 100644
--- a/arch/arm/mach-omap2/board-h4.c
+++ b/arch/arm/mach-omap2/board-h4.c
@@ -186,7 +186,6 @@ static void __init omap_h4_map_io(void)
 
 MACHINE_START(OMAP_H4, "OMAP2420 H4 board")
         /* Maintainer: Paul Mundt <paul.mundt@nokia.com> */
-        .phys_ram       = 0x80000000,
         .phys_io        = 0x48000000,
         .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
diff --git a/arch/arm/mach-pxa/corgi.c b/arch/arm/mach-pxa/corgi.c
index 5a7b873f29b3..7ffd2de8f2f3 100644
--- a/arch/arm/mach-pxa/corgi.c
+++ b/arch/arm/mach-pxa/corgi.c
@@ -342,7 +342,6 @@ static void __init fixup_corgi(struct machine_desc *desc,
 
 #ifdef CONFIG_MACH_CORGI
 MACHINE_START(CORGI, "SHARP Corgi")
-        .phys_ram       = 0xa0000000,
         .phys_io        = 0x40000000,
         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
         .fixup          = fixup_corgi,
@@ -355,7 +354,6 @@ MACHINE_END
 
 #ifdef CONFIG_MACH_SHEPHERD
 MACHINE_START(SHEPHERD, "SHARP Shepherd")
-        .phys_ram       = 0xa0000000,
         .phys_io        = 0x40000000,
         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
         .fixup          = fixup_corgi,
@@ -368,7 +366,6 @@ MACHINE_END
 
 #ifdef CONFIG_MACH_HUSKY
 MACHINE_START(HUSKY, "SHARP Husky")
-        .phys_ram       = 0xa0000000,
         .phys_io        = 0x40000000,
         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
         .fixup          = fixup_corgi,
diff --git a/arch/arm/mach-pxa/idp.c b/arch/arm/mach-pxa/idp.c
index 7de159e2ab42..347b9dea24c6 100644
--- a/arch/arm/mach-pxa/idp.c
+++ b/arch/arm/mach-pxa/idp.c
@@ -183,7 +183,6 @@ static void __init idp_map_io(void)
 
 MACHINE_START(PXA_IDP, "Vibren PXA255 IDP")
         /* Maintainer: Vibren Technologies */
-        .phys_ram       = 0xa0000000,
         .phys_io        = 0x40000000,
         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
         .map_io         = idp_map_io,
diff --git a/arch/arm/mach-pxa/lubbock.c b/arch/arm/mach-pxa/lubbock.c
index b464bc88ff93..3e26d7ce5bb2 100644
--- a/arch/arm/mach-pxa/lubbock.c
+++ b/arch/arm/mach-pxa/lubbock.c
@@ -437,7 +437,6 @@ static void __init lubbock_map_io(void)
 
 MACHINE_START(LUBBOCK, "Intel DBPXA250 Development Platform (aka Lubbock)")
         /* Maintainer: MontaVista Software Inc. */
-        .phys_ram       = 0xa0000000,
         .phys_io        = 0x40000000,
         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
         .map_io         = lubbock_map_io,
diff --git a/arch/arm/mach-pxa/mainstone.c b/arch/arm/mach-pxa/mainstone.c
index 8da9d3efe9a0..d5bda60209ec 100644
--- a/arch/arm/mach-pxa/mainstone.c
+++ b/arch/arm/mach-pxa/mainstone.c
@@ -489,7 +489,6 @@ static void __init mainstone_map_io(void)
 
 MACHINE_START(MAINSTONE, "Intel HCDDBBVA0 Development Platform (aka Mainstone)")
         /* Maintainer: MontaVista Software Inc. */
-        .phys_ram       = 0xa0000000,
         .phys_io        = 0x40000000,
         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
         .map_io         = mainstone_map_io,
diff --git a/arch/arm/mach-pxa/poodle.c b/arch/arm/mach-pxa/poodle.c
index 663c95005985..911e6ff5a9bd 100644
--- a/arch/arm/mach-pxa/poodle.c
+++ b/arch/arm/mach-pxa/poodle.c
@@ -311,7 +311,6 @@ static void __init fixup_poodle(struct machine_desc *desc,
 }
 
 MACHINE_START(POODLE, "SHARP Poodle")
-        .phys_ram       = 0xa0000000,
         .phys_io        = 0x40000000,
         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
         .fixup          = fixup_poodle,
diff --git a/arch/arm/mach-pxa/spitz.c b/arch/arm/mach-pxa/spitz.c
index a9eacc06555f..c094d99ebf56 100644
--- a/arch/arm/mach-pxa/spitz.c
+++ b/arch/arm/mach-pxa/spitz.c
@@ -497,7 +497,6 @@ static void __init fixup_spitz(struct machine_desc *desc,
 
 #ifdef CONFIG_MACH_SPITZ
 MACHINE_START(SPITZ, "SHARP Spitz")
-        .phys_ram       = 0xa0000000,
         .phys_io        = 0x40000000,
         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
         .fixup          = fixup_spitz,
@@ -510,7 +509,6 @@ MACHINE_END
 
 #ifdef CONFIG_MACH_BORZOI
 MACHINE_START(BORZOI, "SHARP Borzoi")
-        .phys_ram       = 0xa0000000,
         .phys_io        = 0x40000000,
         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
         .fixup          = fixup_spitz,
@@ -523,7 +521,6 @@ MACHINE_END
 
 #ifdef CONFIG_MACH_AKITA
 MACHINE_START(AKITA, "SHARP Akita")
-        .phys_ram       = 0xa0000000,
         .phys_io        = 0x40000000,
         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
         .fixup          = fixup_spitz,
diff --git a/arch/arm/mach-pxa/tosa.c b/arch/arm/mach-pxa/tosa.c
index e4f92efc616e..d168286ed470 100644
--- a/arch/arm/mach-pxa/tosa.c
+++ b/arch/arm/mach-pxa/tosa.c
@@ -295,7 +295,6 @@ static void __init fixup_tosa(struct machine_desc *desc,
 }
 
 MACHINE_START(TOSA, "SHARP Tosa")
-        .phys_ram       = 0xa0000000,
         .phys_io        = 0x40000000,
         .io_pg_offst    = (io_p2v(0x40000000) >> 18) & 0xfffc,
         .fixup          = fixup_tosa,
diff --git a/arch/arm/mach-realview/Kconfig b/arch/arm/mach-realview/Kconfig
index 129976866d47..17f5f4439fe7 100644
--- a/arch/arm/mach-realview/Kconfig
+++ b/arch/arm/mach-realview/Kconfig
@@ -3,7 +3,6 @@ menu "RealView platform type"
 
 config MACH_REALVIEW_EB
         bool "Support RealView/EB platform"
-        default n
         select ARM_GIC
         help
           Include support for the ARM(R) RealView Emulation Baseboard platform.
diff --git a/arch/arm/mach-realview/realview_eb.c b/arch/arm/mach-realview/realview_eb.c
index 112f7592aca9..d4a586e38d5b 100644
--- a/arch/arm/mach-realview/realview_eb.c
+++ b/arch/arm/mach-realview/realview_eb.c
@@ -166,7 +166,6 @@ static void __init realview_eb_init(void)
 
 MACHINE_START(REALVIEW_EB, "ARM-RealView EB")
         /* Maintainer: ARM Ltd/Deep Blue Solutions Ltd */
-        .phys_ram       = 0x00000000,
         .phys_io        = REALVIEW_UART0_BASE,
         .io_pg_offst    = (IO_ADDRESS(REALVIEW_UART0_BASE) >> 18) & 0xfffc,
         .boot_params    = 0x00000100,
diff --git a/arch/arm/mach-rpc/riscpc.c b/arch/arm/mach-rpc/riscpc.c
index 5c4ac1c008a6..208a2b5dba1b 100644
--- a/arch/arm/mach-rpc/riscpc.c
+++ b/arch/arm/mach-rpc/riscpc.c
@@ -177,7 +177,6 @@ extern struct sys_timer ioc_timer;
 
 MACHINE_START(RISCPC, "Acorn-RiscPC")
         /* Maintainer: Russell King */
-        .phys_ram       = 0x10000000,
         .phys_io        = 0x03000000,
         .io_pg_offst    = ((0xe0000000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
diff --git a/arch/arm/mach-s3c2410/mach-anubis.c b/arch/arm/mach-s3c2410/mach-anubis.c
index 0f81fc0c2f7f..3e327b8e46be 100644
--- a/arch/arm/mach-s3c2410/mach-anubis.c
+++ b/arch/arm/mach-s3c2410/mach-anubis.c
@@ -294,7 +294,6 @@ static void __init anubis_map_io(void)
 
 MACHINE_START(ANUBIS, "Simtec-Anubis")
         /* Maintainer: Ben Dooks <ben@simtec.co.uk> */
-        .phys_ram       = S3C2410_SDRAM_PA,
         .phys_io        = S3C2410_PA_UART,
         .io_pg_offst    = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
         .boot_params    = S3C2410_SDRAM_PA + 0x100,
diff --git a/arch/arm/mach-s3c2410/mach-bast.c b/arch/arm/mach-s3c2410/mach-bast.c
index 4d962717fdf7..995bb8add331 100644
--- a/arch/arm/mach-s3c2410/mach-bast.c
+++ b/arch/arm/mach-s3c2410/mach-bast.c
@@ -527,7 +527,6 @@ static void __init bast_init(void)
 
 MACHINE_START(BAST, "Simtec-BAST")
         /* Maintainer: Ben Dooks <ben@simtec.co.uk> */
-        .phys_ram       = S3C2410_SDRAM_PA,
         .phys_io        = S3C2410_PA_UART,
         .io_pg_offst    = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
         .boot_params    = S3C2410_SDRAM_PA + 0x100,
diff --git a/arch/arm/mach-s3c2410/mach-h1940.c b/arch/arm/mach-s3c2410/mach-h1940.c
index 0aa8760598f7..1c316f14ed94 100644
--- a/arch/arm/mach-s3c2410/mach-h1940.c
+++ b/arch/arm/mach-s3c2410/mach-h1940.c
@@ -171,7 +171,6 @@ static void __init h1940_init(void)
 
 MACHINE_START(H1940, "IPAQ-H1940")
         /* Maintainer: Ben Dooks <ben@fluff.org> */
-        .phys_ram       = S3C2410_SDRAM_PA,
         .phys_io        = S3C2410_PA_UART,
         .io_pg_offst    = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
         .boot_params    = S3C2410_SDRAM_PA + 0x100,
diff --git a/arch/arm/mach-s3c2410/mach-n30.c b/arch/arm/mach-s3c2410/mach-n30.c
index 378d640ab00b..116ac3169966 100644
--- a/arch/arm/mach-s3c2410/mach-n30.c
+++ b/arch/arm/mach-s3c2410/mach-n30.c
@@ -128,7 +128,6 @@ MACHINE_START(N30, "Acer-N30")
         /* Maintainer: Christer Weinigel <christer@weinigel.se>,
                                 Ben Dooks <ben-linux@fluff.org>
         */
-        .phys_ram       = S3C2410_SDRAM_PA,
         .phys_io        = S3C2410_PA_UART,
         .io_pg_offst    = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
         .boot_params    = S3C2410_SDRAM_PA + 0x100,
diff --git a/arch/arm/mach-s3c2410/mach-nexcoder.c b/arch/arm/mach-s3c2410/mach-nexcoder.c
index 42b0eeff2e0f..07d09509a626 100644
--- a/arch/arm/mach-s3c2410/mach-nexcoder.c
+++ b/arch/arm/mach-s3c2410/mach-nexcoder.c
@@ -148,7 +148,6 @@ static void __init nexcoder_map_io(void)
 
 MACHINE_START(NEXCODER_2440, "NexVision - Nexcoder 2440")
         /* Maintainer: Guillaume GOURAT <guillaume.gourat@nexvision.tv> */
-        .phys_ram       = S3C2410_SDRAM_PA,
         .phys_io        = S3C2410_PA_UART,
         .io_pg_offst    = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
         .boot_params    = S3C2410_SDRAM_PA + 0x100,
diff --git a/arch/arm/mach-s3c2410/mach-otom.c b/arch/arm/mach-s3c2410/mach-otom.c
index a2eb9ed48fcd..b39daedf93ca 100644
--- a/arch/arm/mach-s3c2410/mach-otom.c
+++ b/arch/arm/mach-s3c2410/mach-otom.c
@@ -116,7 +116,6 @@ static void __init otom11_map_io(void)
 
 MACHINE_START(OTOM, "Nex Vision - Otom 1.1")
         /* Maintainer: Guillaume GOURAT <guillaume.gourat@nexvision.tv> */
-        .phys_ram       = S3C2410_SDRAM_PA,
         .phys_io        = S3C2410_PA_UART,
         .io_pg_offst    = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
         .boot_params    = S3C2410_SDRAM_PA + 0x100,
diff --git a/arch/arm/mach-s3c2410/mach-rx3715.c b/arch/arm/mach-s3c2410/mach-rx3715.c
index f8d86d1e16b6..0260ed5ab946 100644
--- a/arch/arm/mach-s3c2410/mach-rx3715.c
+++ b/arch/arm/mach-s3c2410/mach-rx3715.c
@@ -205,7 +205,6 @@ static void __init rx3715_init_machine(void)
 
 MACHINE_START(RX3715, "IPAQ-RX3715")
         /* Maintainer: Ben Dooks <ben@fluff.org> */
-        .phys_ram       = S3C2410_SDRAM_PA,
         .phys_io        = S3C2410_PA_UART,
         .io_pg_offst    = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
         .boot_params    = S3C2410_SDRAM_PA + 0x100,
diff --git a/arch/arm/mach-s3c2410/mach-smdk2410.c b/arch/arm/mach-s3c2410/mach-smdk2410.c
index 2c91965ee1c8..1e76e1fdfcea 100644
--- a/arch/arm/mach-s3c2410/mach-smdk2410.c
+++ b/arch/arm/mach-s3c2410/mach-smdk2410.c
@@ -115,7 +115,6 @@ static void __init smdk2410_init_irq(void)
 MACHINE_START(SMDK2410, "SMDK2410") /* @TODO: request a new identifier and switch
                                     * to SMDK2410 */
         /* Maintainer: Jonas Dietsche */
-        .phys_ram       = S3C2410_SDRAM_PA,
         .phys_io        = S3C2410_PA_UART,
         .io_pg_offst    = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
         .boot_params    = S3C2410_SDRAM_PA + 0x100,
diff --git a/arch/arm/mach-s3c2410/mach-smdk2440.c b/arch/arm/mach-s3c2410/mach-smdk2440.c
index 4e31118533e6..f4315721c3b8 100644
--- a/arch/arm/mach-s3c2410/mach-smdk2440.c
+++ b/arch/arm/mach-s3c2410/mach-smdk2440.c
@@ -216,7 +216,6 @@ static void __init smdk2440_machine_init(void)
 
 MACHINE_START(S3C2440, "SMDK2440")
         /* Maintainer: Ben Dooks <ben@fluff.org> */
-        .phys_ram       = S3C2410_SDRAM_PA,
         .phys_io        = S3C2410_PA_UART,
         .io_pg_offst    = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
         .boot_params    = S3C2410_SDRAM_PA + 0x100,
diff --git a/arch/arm/mach-s3c2410/mach-vr1000.c b/arch/arm/mach-s3c2410/mach-vr1000.c
index ae7e099bf6c8..785fc9cdcf7c 100644
--- a/arch/arm/mach-s3c2410/mach-vr1000.c
+++ b/arch/arm/mach-s3c2410/mach-vr1000.c
@@ -395,7 +395,6 @@ static void __init vr1000_map_io(void)
 
 MACHINE_START(VR1000, "Thorcom-VR1000")
         /* Maintainer: Ben Dooks <ben@simtec.co.uk> */
-        .phys_ram       = S3C2410_SDRAM_PA,
         .phys_io        = S3C2410_PA_UART,
         .io_pg_offst    = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
         .boot_params    = S3C2410_SDRAM_PA + 0x100,
diff --git a/arch/arm/mach-sa1100/assabet.c b/arch/arm/mach-sa1100/assabet.c
index a66ac61233a2..a599bb0d4ab8 100644
--- a/arch/arm/mach-sa1100/assabet.c
+++ b/arch/arm/mach-sa1100/assabet.c
@@ -447,7 +447,6 @@ static void __init assabet_map_io(void)
 
 
 MACHINE_START(ASSABET, "Intel-Assabet")
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xf8000000) >> 18) & 0xfffc,
         .boot_params    = 0xc0000100,
diff --git a/arch/arm/mach-sa1100/badge4.c b/arch/arm/mach-sa1100/badge4.c
index edccd5eb06be..f60b7a66dfa0 100644
--- a/arch/arm/mach-sa1100/badge4.c
+++ b/arch/arm/mach-sa1100/badge4.c
@@ -297,7 +297,6 @@ static void __init badge4_map_io(void)
 }
 
 MACHINE_START(BADGE4, "Hewlett-Packard Laboratories BadgePAD 4")
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xf8000000) >> 18) & 0xfffc,
         .boot_params    = 0xc0000100,
diff --git a/arch/arm/mach-sa1100/cerf.c b/arch/arm/mach-sa1100/cerf.c
index 508593722bc7..8269a9ef9afe 100644
--- a/arch/arm/mach-sa1100/cerf.c
+++ b/arch/arm/mach-sa1100/cerf.c
@@ -135,7 +135,6 @@ static void __init cerf_init(void)
 
 MACHINE_START(CERF, "Intrinsyc CerfBoard/CerfCube")
         /* Maintainer: support@intrinsyc.com */
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xf8000000) >> 18) & 0xfffc,
         .map_io         = cerf_map_io,
diff --git a/arch/arm/mach-sa1100/collie.c b/arch/arm/mach-sa1100/collie.c
index 522abc036d3a..6888816a1935 100644
--- a/arch/arm/mach-sa1100/collie.c
+++ b/arch/arm/mach-sa1100/collie.c
@@ -191,7 +191,6 @@ static void __init collie_map_io(void)
 }
 
 MACHINE_START(COLLIE, "Sharp-Collie")
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xf8000000) >> 18) & 0xfffc,
         .map_io         = collie_map_io,
diff --git a/arch/arm/mach-sa1100/h3600.c b/arch/arm/mach-sa1100/h3600.c
index e8352b7f74b0..b04d92271020 100644
--- a/arch/arm/mach-sa1100/h3600.c
+++ b/arch/arm/mach-sa1100/h3600.c
@@ -392,7 +392,6 @@ static void __init h3100_map_io(void)
 }
 
 MACHINE_START(H3100, "Compaq iPAQ H3100")
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xf8000000) >> 18) & 0xfffc,
         .boot_params    = 0xc0000100,
@@ -510,7 +509,6 @@ static void __init h3600_map_io(void)
 }
 
 MACHINE_START(H3600, "Compaq iPAQ H3600")
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xf8000000) >> 18) & 0xfffc,
         .boot_params    = 0xc0000100,
@@ -897,7 +895,6 @@ static void __init h3800_map_io(void)
 }
 
 MACHINE_START(H3800, "Compaq iPAQ H3800")
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xf8000000) >> 18) & 0xfffc,
         .boot_params    = 0xc0000100,
diff --git a/arch/arm/mach-sa1100/hackkit.c b/arch/arm/mach-sa1100/hackkit.c
index c922e043c424..046b213efd5b 100644
--- a/arch/arm/mach-sa1100/hackkit.c
+++ b/arch/arm/mach-sa1100/hackkit.c
@@ -195,7 +195,6 @@ static void __init hackkit_init(void)
  */
 
 MACHINE_START(HACKKIT, "HackKit Cpu Board")
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xf8000000) >> 18) & 0xfffc,
         .boot_params    = 0xc0000100,
diff --git a/arch/arm/mach-sa1100/jornada720.c b/arch/arm/mach-sa1100/jornada720.c
index 2f671cc3cb99..17f5a43acdb7 100644
--- a/arch/arm/mach-sa1100/jornada720.c
+++ b/arch/arm/mach-sa1100/jornada720.c
@@ -173,7 +173,6 @@ static void __init jornada720_mach_init(void)
 
 MACHINE_START(JORNADA720, "HP Jornada 720")
         /* Maintainer: Michael Gernoth <michael@gernoth.net> */
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xf8000000) >> 18) & 0xfffc,
         .boot_params    = 0xc0000100,
diff --git a/arch/arm/mach-sa1100/lart.c b/arch/arm/mach-sa1100/lart.c
index 8c9e3dd52942..07d3a696ae7f 100644
--- a/arch/arm/mach-sa1100/lart.c
+++ b/arch/arm/mach-sa1100/lart.c
@@ -60,7 +60,6 @@ static void __init lart_map_io(void)
 }
 
 MACHINE_START(LART, "LART")
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xf8000000) >> 18) & 0xfffc,
         .boot_params    = 0xc0000100,
diff --git a/arch/arm/mach-sa1100/pleb.c b/arch/arm/mach-sa1100/pleb.c
index 58c18f9e9b7b..0709ebab531c 100644
--- a/arch/arm/mach-sa1100/pleb.c
+++ b/arch/arm/mach-sa1100/pleb.c
@@ -146,7 +146,6 @@ static void __init pleb_map_io(void)
 }
 
 MACHINE_START(PLEB, "PLEB")
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xf8000000) >> 18) & 0xfffc,
         .map_io         = pleb_map_io,
diff --git a/arch/arm/mach-sa1100/shannon.c b/arch/arm/mach-sa1100/shannon.c
index 7482288278d9..5aafe0b56992 100644
--- a/arch/arm/mach-sa1100/shannon.c
+++ b/arch/arm/mach-sa1100/shannon.c
@@ -83,7 +83,6 @@ static void __init shannon_map_io(void)
 }
 
 MACHINE_START(SHANNON, "Shannon (AKA: Tuxscreen)")
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xf8000000) >> 18) & 0xfffc,
         .boot_params    = 0xc0000100,
diff --git a/arch/arm/mach-sa1100/simpad.c b/arch/arm/mach-sa1100/simpad.c
index 439ddc9b06d6..d2c23b2c34d1 100644
--- a/arch/arm/mach-sa1100/simpad.c
+++ b/arch/arm/mach-sa1100/simpad.c
@@ -229,7 +229,6 @@ arch_initcall(simpad_init);
 
 MACHINE_START(SIMPAD, "Simpad")
         /* Maintainer: Holger Freyther */
-        .phys_ram       = 0xc0000000,
         .phys_io        = 0x80000000,
         .io_pg_offst    = ((0xf8000000) >> 18) & 0xfffc,
         .boot_params    = 0xc0000100,
diff --git a/arch/arm/mach-shark/core.c b/arch/arm/mach-shark/core.c
index 2d428b6dbb58..877600e212dd 100644
--- a/arch/arm/mach-shark/core.c
+++ b/arch/arm/mach-shark/core.c
@@ -111,7 +111,6 @@ static struct sys_timer shark_timer = {
 
 MACHINE_START(SHARK, "Shark")
         /* Maintainer: Alexander Schulz */
-        .phys_ram       = 0x08000000,
         .phys_io        = 0x40000000,
         .io_pg_offst    = ((0xe0000000) >> 18) & 0xfffc,
         .boot_params    = 0x08003000,
diff --git a/arch/arm/mach-versatile/Kconfig b/arch/arm/mach-versatile/Kconfig
index 8d787f4c78e6..95096afd5271 100644
--- a/arch/arm/mach-versatile/Kconfig
+++ b/arch/arm/mach-versatile/Kconfig
@@ -9,7 +9,6 @@ config ARCH_VERSATILE_PB
 
 config MACH_VERSATILE_AB
         bool "Support Versatile/AB platform"
-        default n
         help
           Include support for the ARM(R) Versatile/AP platform.
 
diff --git a/arch/arm/mach-versatile/core.c b/arch/arm/mach-versatile/core.c
index 90023745b23a..9ebbe808b41d 100644
--- a/arch/arm/mach-versatile/core.c
+++ b/arch/arm/mach-versatile/core.c
@@ -35,6 +35,7 @@
 #include <asm/leds.h>
 #include <asm/hardware/arm_timer.h>
 #include <asm/hardware/icst307.h>
+#include <asm/hardware/vic.h>
 
 #include <asm/mach/arch.h>
 #include <asm/mach/flash.h>
@@ -56,24 +57,6 @@
 #define VA_VIC_BASE             __io_address(VERSATILE_VIC_BASE)
 #define VA_SIC_BASE             __io_address(VERSATILE_SIC_BASE)
 
-static void vic_mask_irq(unsigned int irq)
-{
-        irq -= IRQ_VIC_START;
-        writel(1 << irq, VA_VIC_BASE + VIC_IRQ_ENABLE_CLEAR);
-}
-
-static void vic_unmask_irq(unsigned int irq)
-{
-        irq -= IRQ_VIC_START;
-        writel(1 << irq, VA_VIC_BASE + VIC_IRQ_ENABLE);
-}
-
-static struct irqchip vic_chip = {
-        .ack    = vic_mask_irq,
-        .mask   = vic_mask_irq,
-        .unmask = vic_unmask_irq,
-};
-
 static void sic_mask_irq(unsigned int irq)
 {
         irq -= IRQ_SIC_START;
@@ -127,43 +110,12 @@ sic_handle_irq(unsigned int irq, struct irqdesc *desc, struct pt_regs *regs)
 
 void __init versatile_init_irq(void)
 {
-        unsigned int i, value;
-
-        /* Disable all interrupts initially. */
+        unsigned int i;
 
-        writel(0, VA_VIC_BASE + VIC_INT_SELECT);
-        writel(0, VA_VIC_BASE + VIC_IRQ_ENABLE);
-        writel(~0, VA_VIC_BASE + VIC_IRQ_ENABLE_CLEAR);
-        writel(0, VA_VIC_BASE + VIC_IRQ_STATUS);
-        writel(0, VA_VIC_BASE + VIC_ITCR);
-        writel(~0, VA_VIC_BASE + VIC_IRQ_SOFT_CLEAR);
-
-        /*
-         * Make sure we clear all existing interrupts
-         */
-        writel(0, VA_VIC_BASE + VIC_VECT_ADDR);
-        for (i = 0; i < 19; i++) {
-                value = readl(VA_VIC_BASE + VIC_VECT_ADDR);
-                writel(value, VA_VIC_BASE + VIC_VECT_ADDR);
-        }
-
-        for (i = 0; i < 16; i++) {
-                value = readl(VA_VIC_BASE + VIC_VECT_CNTL0 + (i * 4));
-                writel(value | VICVectCntl_Enable | i, VA_VIC_BASE + VIC_VECT_CNTL0 + (i * 4));
-        }
-
-        writel(32, VA_VIC_BASE + VIC_DEF_VECT_ADDR);
-
-        for (i = IRQ_VIC_START; i <= IRQ_VIC_END; i++) {
-                if (i != IRQ_VICSOURCE31) {
-                        set_irq_chip(i, &vic_chip);
-                        set_irq_handler(i, do_level_IRQ);
-                        set_irq_flags(i, IRQF_VALID | IRQF_PROBE);
-                }
-        }
+        vic_init(VA_VIC_BASE, ~(1 << 31));
 
         set_irq_handler(IRQ_VICSOURCE31, sic_handle_irq);
-        vic_unmask_irq(IRQ_VICSOURCE31);
+        enable_irq(IRQ_VICSOURCE31);
 
         /* Do second interrupt controller */
         writel(~0, VA_SIC_BASE + SIC_IRQ_ENABLE_CLEAR);
@@ -877,7 +829,7 @@ static unsigned long versatile_gettimeoffset(void)
         ticks2 = readl(TIMER0_VA_BASE + TIMER_VALUE) & 0xffff;
         do {
                 ticks1 = ticks2;
-                status = __raw_readl(VA_IC_BASE + VIC_IRQ_RAW_STATUS);
+                status = __raw_readl(VA_IC_BASE + VIC_RAW_STATUS);
                 ticks2 = readl(TIMER0_VA_BASE + TIMER_VALUE) & 0xffff;
         } while (ticks2 > ticks1);
 
diff --git a/arch/arm/mach-versatile/versatile_ab.c b/arch/arm/mach-versatile/versatile_ab.c
index e74c8a2fbb95..1eb596782078 100644
--- a/arch/arm/mach-versatile/versatile_ab.c
+++ b/arch/arm/mach-versatile/versatile_ab.c
@@ -36,7 +36,6 @@
 
 MACHINE_START(VERSATILE_AB, "ARM-Versatile AB")
         /* Maintainer: ARM Ltd/Deep Blue Solutions Ltd */
-        .phys_ram       = 0x00000000,
         .phys_io        = 0x101f1000,
         .io_pg_offst    = ((0xf11f1000) >> 18) & 0xfffc,
         .boot_params    = 0x00000100,
diff --git a/arch/arm/mach-versatile/versatile_pb.c b/arch/arm/mach-versatile/versatile_pb.c
index 22d5ca07f75d..f17ab4fb548a 100644
--- a/arch/arm/mach-versatile/versatile_pb.c
+++ b/arch/arm/mach-versatile/versatile_pb.c
@@ -100,7 +100,6 @@ arch_initcall(versatile_pb_init);
 
 MACHINE_START(VERSATILE_PB, "ARM-Versatile PB")
         /* Maintainer: ARM Ltd/Deep Blue Solutions Ltd */
-        .phys_ram       = 0x00000000,
         .phys_io        = 0x101f1000,
         .io_pg_offst    = ((0xf11f1000) >> 18) & 0xfffc,
         .boot_params    = 0x00000100,
diff --git a/arch/arm/nwfpe/fpa11.h b/arch/arm/nwfpe/fpa11.h
index da4c616b6c49..28cd79a451d3 100644
--- a/arch/arm/nwfpe/fpa11.h
+++ b/arch/arm/nwfpe/fpa11.h
@@ -62,7 +62,7 @@ typedef union tagFPREG {
 #else
         u32 padding[3];
 #endif
-} FPREG;
+} __attribute__ ((packed,aligned(4))) FPREG;
 
 /*
  * FPA11 device model.
@@ -89,7 +89,7 @@ typedef struct tagFPA11 {
                                    so we can use it to detect whether this
                                    instance of the emulator needs to be
                                    initialised. */
-} FPA11;
+} __attribute__ ((packed,aligned(4))) FPA11;
 
 extern int8 SetRoundingMode(const unsigned int);
 extern int8 SetRoundingPrecision(const unsigned int);
diff --git a/arch/arm/plat-omap/Kconfig b/arch/arm/plat-omap/Kconfig
index 9693e9b4ffd1..0887bb2a2551 100644
--- a/arch/arm/plat-omap/Kconfig
+++ b/arch/arm/plat-omap/Kconfig
@@ -22,7 +22,6 @@ comment "OMAP Feature Selections"
 config OMAP_RESET_CLOCKS
         bool "Reset unused clocks during boot"
         depends on ARCH_OMAP
-        default n
         help
           Say Y if you want to reset unused clocks during boot.
           This option saves power, but assumes all drivers are
@@ -44,7 +43,6 @@ config OMAP_MUX
 config OMAP_MUX_DEBUG
         bool "Multiplexing debug output"
         depends on OMAP_MUX
-        default n
         help
           Makes the multiplexing functions print out a lot of debug info.
           This is useful if you want to find out the correct values of the
@@ -93,7 +91,6 @@ config OMAP_32K_TIMER_HZ
 
 config OMAP_DM_TIMER
         bool "Use dual-mode timer"
-        default n
         depends on ARCH_OMAP16XX
         help
          Select this option if you want to use OMAP Dual-Mode timers.
diff --git a/arch/i386/Kconfig b/arch/i386/Kconfig
index d5d0df7f04fc..cbde675bc95c 100644
--- a/arch/i386/Kconfig
+++ b/arch/i386/Kconfig
@@ -702,6 +702,15 @@ config PHYSICAL_START
 
           Don't change this unless you know what you are doing.
 
+config HOTPLUG_CPU
+        bool "Support for hot-pluggable CPUs (EXPERIMENTAL)"
+        depends on SMP && HOTPLUG && EXPERIMENTAL
+        ---help---
+          Say Y here to experiment with turning CPUs off and on.  CPUs
+          can be controlled through /sys/devices/system/cpu.
+
+          Say N.
+
 endmenu
 
 
@@ -988,15 +997,6 @@ config SCx200
           This support is also available as a module.  If compiled as a
           module, it will be called scx200.
 
-config HOTPLUG_CPU
-        bool "Support for hot-pluggable CPUs (EXPERIMENTAL)"
-        depends on SMP && HOTPLUG && EXPERIMENTAL
-        ---help---
-          Say Y here to experiment with turning CPUs off and on.  CPUs
-          can be controlled through /sys/devices/system/cpu.
-
-          Say N.
-
 source "drivers/pcmcia/Kconfig"
 
 source "drivers/pci/hotplug/Kconfig"
diff --git a/arch/i386/Makefile b/arch/i386/Makefile
index d3c0409d201c..bd2d53a9dd2b 100644
--- a/arch/i386/Makefile
+++ b/arch/i386/Makefile
@@ -42,9 +42,9 @@ include $(srctree)/arch/i386/Makefile.cpu
 cflags-$(CONFIG_REGPARM) += $(shell if [ $(call cc-version) -ge 0300 ] ; then \
                             echo "-mregparm=3"; fi ;)
 
-# Disable unit-at-a-time mode, it makes gcc use a lot more stack
-# due to the lack of sharing of stacklots.
-CFLAGS += $(call cc-option,-fno-unit-at-a-time)
+# Disable unit-at-a-time mode on pre-gcc-4.0 compilers, it makes gcc use
+# a lot more stack due to the lack of sharing of stacklots:
+CFLAGS                          += $(shell if [ $(call cc-version) -lt 0400 ] ; then echo $(call cc-option,-fno-unit-at-a-time); fi ;)
 
 CFLAGS += $(cflags-y)
 
diff --git a/arch/i386/kernel/traps.c b/arch/i386/kernel/traps.c
index b9f0030a2ebb..0aaebf3e1cfa 100644
--- a/arch/i386/kernel/traps.c
+++ b/arch/i386/kernel/traps.c
@@ -112,33 +112,38 @@ static inline int valid_stack_ptr(struct thread_info *tinfo, void *p)
                 p < (void *)tinfo + THREAD_SIZE - 3;
 }
 
+static void print_addr_and_symbol(unsigned long addr, char *log_lvl)
+{
+        printk(log_lvl);
+        printk(" [<%08lx>] ", addr);
+        print_symbol("%s", addr);
+        printk("\n");
+}
+
 static inline unsigned long print_context_stack(struct thread_info *tinfo,
-                                unsigned long *stack, unsigned long ebp)
+                                unsigned long *stack, unsigned long ebp,
+                                char *log_lvl)
 {
         unsigned long addr;
 
 #ifdef  CONFIG_FRAME_POINTER
         while (valid_stack_ptr(tinfo, (void *)ebp)) {
                 addr = *(unsigned long *)(ebp + 4);
-                printk(KERN_EMERG " [<%08lx>] ", addr);
-                print_symbol("%s", addr);
-                printk("\n");
+                print_addr_and_symbol(addr, log_lvl);
                 ebp = *(unsigned long *)ebp;
         }
 #else
         while (valid_stack_ptr(tinfo, stack)) {
                 addr = *stack++;
-                if (__kernel_text_address(addr)) {
-                        printk(KERN_EMERG " [<%08lx>]", addr);
-                        print_symbol(" %s", addr);
-                        printk("\n");
-                }
+                if (__kernel_text_address(addr))
+                        print_addr_and_symbol(addr, log_lvl);
         }
 #endif
         return ebp;
 }
 
-void show_trace(struct task_struct *task, unsigned long * stack)
+static void show_trace_log_lvl(struct task_struct *task,
+                               unsigned long *stack, char *log_lvl)
 {
         unsigned long ebp;
 
@@ -157,7 +162,7 @@ void show_trace(struct task_struct *task, unsigned long * stack)
                 struct thread_info *context;
                 context = (struct thread_info *)
                         ((unsigned long)stack & (~(THREAD_SIZE - 1)));
-                ebp = print_context_stack(context, stack, ebp);
+                ebp = print_context_stack(context, stack, ebp, log_lvl);
                 stack = (unsigned long*)context->previous_esp;
                 if (!stack)
                         break;
@@ -165,7 +170,13 @@ void show_trace(struct task_struct *task, unsigned long * stack)
         }
 }
 
-void show_stack(struct task_struct *task, unsigned long *esp)
+void show_trace(struct task_struct *task, unsigned long * stack)
+{
+        show_trace_log_lvl(task, stack, "");
+}
+
+static void show_stack_log_lvl(struct task_struct *task, unsigned long *esp,
+                               char *log_lvl)
 {
         unsigned long *stack;
         int i;
@@ -178,16 +189,26 @@ void show_stack(struct task_struct *task, unsigned long *esp)
         }
 
         stack = esp;
-        printk(KERN_EMERG);
+        printk(log_lvl);
         for(i = 0; i < kstack_depth_to_print; i++) {
                 if (kstack_end(stack))
                         break;
-                if (i && ((i % 8) == 0))
-                        printk("\n" KERN_EMERG "       ");
+                if (i && ((i % 8) == 0)) {
+                        printk("\n");
+                        printk(log_lvl);
+                        printk("       ");
+                }
                 printk("%08lx ", *stack++);
         }
-        printk("\n" KERN_EMERG "Call Trace:\n");
-        show_trace(task, esp);
+        printk("\n");
+        printk(log_lvl);
+        printk("Call Trace:\n");
+        show_trace_log_lvl(task, esp, log_lvl);
+}
+
+void show_stack(struct task_struct *task, unsigned long *esp)
+{
+        show_stack_log_lvl(task, esp, "");
 }
 
 /*
@@ -238,7 +259,7 @@ void show_registers(struct pt_regs *regs)
                 u8 __user *eip;
 
                 printk("\n" KERN_EMERG "Stack: ");
-                show_stack(NULL, (unsigned long*)esp);
+                show_stack_log_lvl(NULL, (unsigned long *)esp, KERN_EMERG);
 
                 printk(KERN_EMERG "Code: ");
 
diff --git a/arch/i386/pci/fixup.c b/arch/i386/pci/fixup.c
index 65f67070db64..83c3645ccc43 100644
--- a/arch/i386/pci/fixup.c
+++ b/arch/i386/pci/fixup.c
@@ -449,3 +449,19 @@ static void __devinit pci_post_fixup_toshiba_ohci1394(struct pci_dev *dev)
 }
 DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_TI, 0x8032,
                          pci_post_fixup_toshiba_ohci1394);
+
+
+/*
+ * Prevent the BIOS trapping accesses to the Cyrix CS5530A video device
+ * configuration space.
+ */
+static void __devinit pci_early_fixup_cyrix_5530(struct pci_dev *dev)
+{
+        u8 r;
+        /* clear 'F4 Video Configuration Trap' bit */
+        pci_read_config_byte(dev, 0x42, &r);
+        r &= 0xfd;
+        pci_write_config_byte(dev, 0x42, r);
+}
+DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5530_LEGACY,
+                        pci_early_fixup_cyrix_5530);
diff --git a/arch/ia64/configs/gensparse_defconfig b/arch/ia64/configs/gensparse_defconfig
index 80f8663bc6d9..1d07d8072ec2 100644
--- a/arch/ia64/configs/gensparse_defconfig
+++ b/arch/ia64/configs/gensparse_defconfig
@@ -701,6 +701,7 @@ CONFIG_SERIAL_CORE_CONSOLE=y
 CONFIG_SERIAL_SGI_L1_CONSOLE=y
 # CONFIG_SERIAL_JSM is not set
 CONFIG_SERIAL_SGI_IOC4=y
+CONFIG_SERIAL_SGI_IOC3=y
 CONFIG_UNIX98_PTYS=y
 CONFIG_LEGACY_PTYS=y
 CONFIG_LEGACY_PTY_COUNT=256
@@ -1046,6 +1047,7 @@ CONFIG_INFINIBAND_IPOIB=m
 # SN Devices
 #
 CONFIG_SGI_IOC4=y
+CONFIG_SGI_IOC3=y
 
 #
 # File systems
diff --git a/arch/ia64/configs/sn2_defconfig b/arch/ia64/configs/sn2_defconfig
index ff8bb3770c9d..3cb503b659e6 100644
--- a/arch/ia64/configs/sn2_defconfig
+++ b/arch/ia64/configs/sn2_defconfig
@@ -659,6 +659,7 @@ CONFIG_SERIAL_CORE_CONSOLE=y
 CONFIG_SERIAL_SGI_L1_CONSOLE=y
 # CONFIG_SERIAL_JSM is not set
 CONFIG_SERIAL_SGI_IOC4=y
+CONFIG_SERIAL_SGI_IOC3=y
 CONFIG_UNIX98_PTYS=y
 CONFIG_LEGACY_PTYS=y
 CONFIG_LEGACY_PTY_COUNT=256
@@ -899,6 +900,7 @@ CONFIG_INFINIBAND_SRP=m
 # SN Devices
 #
 CONFIG_SGI_IOC4=y
+CONFIG_SGI_IOC3=y
 
 #
 # File systems
diff --git a/arch/ia64/hp/sim/simserial.c b/arch/ia64/hp/sim/simserial.c
index a346e1833bf2..626cdc83668b 100644
--- a/arch/ia64/hp/sim/simserial.c
+++ b/arch/ia64/hp/sim/simserial.c
@@ -108,7 +108,6 @@ static struct async_struct *IRQ_ports[NR_IRQS];
 static struct console *console;
 
 static unsigned char *tmp_buf;
-static DECLARE_MUTEX(tmp_buf_sem);
 
 extern struct console *console_drivers; /* from kernel/printk.c */
 
@@ -167,15 +166,9 @@ static  void receive_chars(struct tty_struct *tty, struct pt_regs *regs)
                         }
                 }
                 seen_esc = 0;
-                if (tty->flip.count >= TTY_FLIPBUF_SIZE) break;
 
-                *tty->flip.char_buf_ptr = ch;
-
-                *tty->flip.flag_buf_ptr = 0;
-
-                tty->flip.flag_buf_ptr++;
-                tty->flip.char_buf_ptr++;
-                tty->flip.count++;
+                if (tty_insert_flip_char(tty, ch, TTY_NORMAL) == 0)
+                        break;
         }
         tty_flip_buffer_push(tty);
 }
diff --git a/arch/ia64/kernel/fsys.S b/arch/ia64/kernel/fsys.S
index 2ddbac6f4999..ce423910ca97 100644
--- a/arch/ia64/kernel/fsys.S
+++ b/arch/ia64/kernel/fsys.S
@@ -903,5 +903,6 @@ fsyscall_table:
         data8 0
         data8 0
         data8 0
+        data8 0                                                 // 1280
 
         .org fsyscall_table + 8*NR_syscalls     // guard against failures to increase NR_syscalls
diff --git a/arch/ia64/kernel/jprobes.S b/arch/ia64/kernel/jprobes.S
index 2323377e3695..5cd6226f44f2 100644
--- a/arch/ia64/kernel/jprobes.S
+++ b/arch/ia64/kernel/jprobes.S
@@ -60,3 +60,30 @@ END(jprobe_break)
 GLOBAL_ENTRY(jprobe_inst_return)
         br.call.sptk.many b0=jprobe_break
 END(jprobe_inst_return)
+
+GLOBAL_ENTRY(invalidate_stacked_regs)
+        movl r16=invalidate_restore_cfm
+        ;;
+        mov b6=r16
+        ;;
+        br.ret.sptk.many b6
+        ;;
+invalidate_restore_cfm:
+        mov r16=ar.rsc
+        ;;
+        mov ar.rsc=r0
+        ;;
+        loadrs
+        ;;
+        mov ar.rsc=r16
+        ;;
+        br.cond.sptk.many rp
+END(invalidate_stacked_regs)
+
+GLOBAL_ENTRY(flush_register_stack)
+        // flush dirty regs to backing store (must be first in insn group)
+        flushrs
+        ;;
+        br.ret.sptk.many rp
+END(flush_register_stack)
+
diff --git a/arch/ia64/kernel/kprobes.c b/arch/ia64/kernel/kprobes.c
index 346fedf9ea47..50ae8c7d453d 100644
--- a/arch/ia64/kernel/kprobes.c
+++ b/arch/ia64/kernel/kprobes.c
@@ -766,11 +766,56 @@ int __kprobes kprobe_exceptions_notify(struct notifier_block *self,
         return ret;
 }
 
+struct param_bsp_cfm {
+        unsigned long ip;
+        unsigned long *bsp;
+        unsigned long cfm;
+};
+
+static void ia64_get_bsp_cfm(struct unw_frame_info *info, void *arg)
+{
+        unsigned long ip;
+        struct param_bsp_cfm *lp = arg;
+
+        do {
+                unw_get_ip(info, &ip);
+                if (ip == 0)
+                        break;
+                if (ip == lp->ip) {
+                        unw_get_bsp(info, (unsigned long*)&lp->bsp);
+                        unw_get_cfm(info, (unsigned long*)&lp->cfm);
+                        return;
+                }
+        } while (unw_unwind(info) >= 0);
+        lp->bsp = 0;
+        lp->cfm = 0;
+        return;
+}
+
 int __kprobes setjmp_pre_handler(struct kprobe *p, struct pt_regs *regs)
 {
         struct jprobe *jp = container_of(p, struct jprobe, kp);
         unsigned long addr = ((struct fnptr *)(jp->entry))->ip;
         struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
+        struct param_bsp_cfm pa;
+        int bytes;
+
+        /*
+         * Callee owns the argument space and could overwrite it, eg
+         * tail call optimization. So to be absolutely safe
+         * we save the argument space before transfering the control
+         * to instrumented jprobe function which runs in
+         * the process context
+         */
+        pa.ip = regs->cr_iip;
+        unw_init_running(ia64_get_bsp_cfm, &pa);
+        bytes = (char *)ia64_rse_skip_regs(pa.bsp, pa.cfm & 0x3f)
+                                - (char *)pa.bsp;
+        memcpy( kcb->jprobes_saved_stacked_regs,
+                pa.bsp,
+                bytes );
+        kcb->bsp = pa.bsp;
+        kcb->cfm = pa.cfm;
 
         /* save architectural state */
         kcb->jprobe_saved_regs = *regs;
@@ -792,8 +837,20 @@ int __kprobes setjmp_pre_handler(struct kprobe *p, struct pt_regs *regs)
 int __kprobes longjmp_break_handler(struct kprobe *p, struct pt_regs *regs)
 {
         struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
+        int bytes;
 
+        /* restoring architectural state */
         *regs = kcb->jprobe_saved_regs;
+
+        /* restoring the original argument space */
+        flush_register_stack();
+        bytes = (char *)ia64_rse_skip_regs(kcb->bsp, kcb->cfm & 0x3f)
+                                - (char *)kcb->bsp;
+        memcpy( kcb->bsp,
+                kcb->jprobes_saved_stacked_regs,
+                bytes );
+        invalidate_stacked_regs();
+
         preempt_enable_no_resched();
         return 1;
 }
diff --git a/arch/ia64/kernel/mca_asm.S b/arch/ia64/kernel/mca_asm.S
index db32fc1d3935..403a80a58c13 100644
--- a/arch/ia64/kernel/mca_asm.S
+++ b/arch/ia64/kernel/mca_asm.S
@@ -847,7 +847,7 @@ ia64_state_restore:
         ;;
         mov cr.iim=temp3
         mov cr.iha=temp4
-        dep r22=0,r22,62,2      // pal_min_state, physical, uncached
+        dep r22=0,r22,62,1      // pal_min_state, physical, uncached
         mov IA64_KR(CURRENT)=r21
         ld8 r8=[temp1]          // os_status
         ld8 r10=[temp2]         // context
diff --git a/arch/ia64/kernel/salinfo.c b/arch/ia64/kernel/salinfo.c
index a87a162a3086..9d5a823479a3 100644
--- a/arch/ia64/kernel/salinfo.c
+++ b/arch/ia64/kernel/salinfo.c
@@ -3,7 +3,7 @@
  *
  * Creates entries in /proc/sal for various system features.
  *
- * Copyright (c) 2003 Silicon Graphics, Inc.  All rights reserved.
+ * Copyright (c) 2003, 2006 Silicon Graphics, Inc.  All rights reserved.
  * Copyright (c) 2003 Hewlett-Packard Co
  *      Bjorn Helgaas <bjorn.helgaas@hp.com>
  *
@@ -27,9 +27,17 @@
  *   mca.c may not pass a buffer, a NULL buffer just indicates that a new
  *   record is available in SAL.
  *   Replace some NR_CPUS by cpus_online, for hotplug cpu.
+ *
+ * Jan  5 2006        kaos@sgi.com
+ *   Handle hotplug cpus coming online.
+ *   Handle hotplug cpus going offline while they still have outstanding records.
+ *   Use the cpu_* macros consistently.
+ *   Replace the counting semaphore with a mutex and a test if the cpumask is non-empty.
+ *   Modify the locking to make the test for "work to do" an atomic operation.
  */
 
 #include <linux/capability.h>
+#include <linux/cpu.h>
 #include <linux/types.h>
 #include <linux/proc_fs.h>
 #include <linux/module.h>
@@ -132,8 +140,8 @@ enum salinfo_state {
 };
 
 struct salinfo_data {
-        volatile cpumask_t      cpu_event;      /* which cpus have outstanding events */
-        struct semaphore        sem;            /* count of cpus with outstanding events (bits set in cpu_event) */
+        cpumask_t               cpu_event;      /* which cpus have outstanding events */
+        struct semaphore        mutex;
         u8                      *log_buffer;
         u64                     log_size;
         u8                      *oemdata;       /* decoded oem data */
@@ -174,6 +182,21 @@ struct salinfo_platform_oemdata_parms {
         int ret;
 };
 
+/* Kick the mutex that tells user space that there is work to do.  Instead of
+ * trying to track the state of the mutex across multiple cpus, in user
+ * context, interrupt context, non-maskable interrupt context and hotplug cpu,
+ * it is far easier just to grab the mutex if it is free then release it.
+ *
+ * This routine must be called with data_saved_lock held, to make the down/up
+ * operation atomic.
+ */
+static void
+salinfo_work_to_do(struct salinfo_data *data)
+{
+        down_trylock(&data->mutex);
+        up(&data->mutex);
+}
+
 static void
 salinfo_platform_oemdata_cpu(void *context)
 {
@@ -212,9 +235,9 @@ salinfo_log_wakeup(int type, u8 *buffer, u64 size, int irqsafe)
 
         BUG_ON(type >= ARRAY_SIZE(salinfo_log_name));
 
+        if (irqsafe)
+                spin_lock_irqsave(&data_saved_lock, flags);
         if (buffer) {
-                if (irqsafe)
-                        spin_lock_irqsave(&data_saved_lock, flags);
                 for (i = 0, data_saved = data->data_saved; i < saved_size; ++i, ++data_saved) {
                         if (!data_saved->buffer)
                                 break;
@@ -232,13 +255,11 @@ salinfo_log_wakeup(int type, u8 *buffer, u64 size, int irqsafe)
                         data_saved->size = size;
                         data_saved->buffer = buffer;
                 }
-                if (irqsafe)
-                        spin_unlock_irqrestore(&data_saved_lock, flags);
         }
-
-        if (!test_and_set_bit(smp_processor_id(), &data->cpu_event)) {
-                if (irqsafe)
-                        up(&data->sem);
+        cpu_set(smp_processor_id(), data->cpu_event);
+        if (irqsafe) {
+                salinfo_work_to_do(data);
+                spin_unlock_irqrestore(&data_saved_lock, flags);
         }
 }
 
@@ -249,20 +270,17 @@ static struct timer_list salinfo_timer;
 static void
 salinfo_timeout_check(struct salinfo_data *data)
 {
-        int i;
+        unsigned long flags;
         if (!data->open)
                 return;
-        for_each_online_cpu(i) {
-                if (test_bit(i, &data->cpu_event)) {
-                        /* double up() is not a problem, user space will see no
-                         * records for the additional "events".
-                         */
-                        up(&data->sem);
-                }
+        if (!cpus_empty(data->cpu_event)) {
+                spin_lock_irqsave(&data_saved_lock, flags);
+                salinfo_work_to_do(data);
+                spin_unlock_irqrestore(&data_saved_lock, flags);
         }
 }
 
-static void 
+static void
 salinfo_timeout (unsigned long arg)
 {
         salinfo_timeout_check(salinfo_data + SAL_INFO_TYPE_MCA);
@@ -290,16 +308,20 @@ salinfo_event_read(struct file *file, char __user *buffer, size_t count, loff_t
         int i, n, cpu = -1;
 
 retry:
-        if (down_trylock(&data->sem)) {
+        if (cpus_empty(data->cpu_event) && down_trylock(&data->mutex)) {
                 if (file->f_flags & O_NONBLOCK)
                         return -EAGAIN;
-                if (down_interruptible(&data->sem))
+                if (down_interruptible(&data->mutex))
                         return -EINTR;
         }
 
         n = data->cpu_check;
         for (i = 0; i < NR_CPUS; i++) {
-                if (test_bit(n, &data->cpu_event) && cpu_online(n)) {
+                if (cpu_isset(n, data->cpu_event)) {
+                        if (!cpu_online(n)) {
+                                cpu_clear(n, data->cpu_event);
+                                continue;
+                        }
                         cpu = n;
                         break;
                 }
@@ -310,9 +332,6 @@ retry:
         if (cpu == -1)
                 goto retry;
 
-        /* events are sticky until the user says "clear" */
-        up(&data->sem);
-
         /* for next read, start checking at next CPU */
         data->cpu_check = cpu;
         if (++data->cpu_check == NR_CPUS)
@@ -381,10 +400,8 @@ salinfo_log_release(struct inode *inode, struct file *file)
 static void
 call_on_cpu(int cpu, void (*fn)(void *), void *arg)
 {
-        cpumask_t save_cpus_allowed, new_cpus_allowed;
-        memcpy(&save_cpus_allowed, &current->cpus_allowed, sizeof(save_cpus_allowed));
-        memset(&new_cpus_allowed, 0, sizeof(new_cpus_allowed));
-        set_bit(cpu, &new_cpus_allowed);
+        cpumask_t save_cpus_allowed = current->cpus_allowed;
+        cpumask_t new_cpus_allowed = cpumask_of_cpu(cpu);
         set_cpus_allowed(current, new_cpus_allowed);
         (*fn)(arg);
         set_cpus_allowed(current, save_cpus_allowed);
@@ -433,10 +450,10 @@ retry:
         if (!data->saved_num)
                 call_on_cpu(cpu, salinfo_log_read_cpu, data);
         if (!data->log_size) {
-                data->state = STATE_NO_DATA;
-                clear_bit(cpu, &data->cpu_event);
+                data->state = STATE_NO_DATA;
+                cpu_clear(cpu, data->cpu_event);
         } else {
-                data->state = STATE_LOG_RECORD;
+                data->state = STATE_LOG_RECORD;
         }
 }
 
@@ -473,27 +490,31 @@ static int
 salinfo_log_clear(struct salinfo_data *data, int cpu)
 {
         sal_log_record_header_t *rh;
+        unsigned long flags;
+        spin_lock_irqsave(&data_saved_lock, flags);
         data->state = STATE_NO_DATA;
-        if (!test_bit(cpu, &data->cpu_event))
+        if (!cpu_isset(cpu, data->cpu_event)) {
+                spin_unlock_irqrestore(&data_saved_lock, flags);
                 return 0;
-        down(&data->sem);
-        clear_bit(cpu, &data->cpu_event);
+        }
+        cpu_clear(cpu, data->cpu_event);
         if (data->saved_num) {
-                unsigned long flags;
-                spin_lock_irqsave(&data_saved_lock, flags);
-                shift1_data_saved(data, data->saved_num - 1 );
+                shift1_data_saved(data, data->saved_num - 1);
                 data->saved_num = 0;
-                spin_unlock_irqrestore(&data_saved_lock, flags);
         }
+        spin_unlock_irqrestore(&data_saved_lock, flags);
         rh = (sal_log_record_header_t *)(data->log_buffer);
         /* Corrected errors have already been cleared from SAL */
         if (rh->severity != sal_log_severity_corrected)
                 call_on_cpu(cpu, salinfo_log_clear_cpu, data);
         /* clearing a record may make a new record visible */
         salinfo_log_new_read(cpu, data);
-        if (data->state == STATE_LOG_RECORD &&
-            !test_and_set_bit(cpu,  &data->cpu_event))
-                up(&data->sem);
+        if (data->state == STATE_LOG_RECORD) {
+                spin_lock_irqsave(&data_saved_lock, flags);
+                cpu_set(cpu, data->cpu_event);
+                salinfo_work_to_do(data);
+                spin_unlock_irqrestore(&data_saved_lock, flags);
+        }
         return 0;
 }
 
@@ -550,6 +571,53 @@ static struct file_operations salinfo_data_fops = {
         .write   = salinfo_log_write,
 };
 
+#ifdef  CONFIG_HOTPLUG_CPU
+static int __devinit
+salinfo_cpu_callback(struct notifier_block *nb, unsigned long action, void *hcpu)
+{
+        unsigned int i, cpu = (unsigned long)hcpu;
+        unsigned long flags;
+        struct salinfo_data *data;
+        switch (action) {
+        case CPU_ONLINE:
+                spin_lock_irqsave(&data_saved_lock, flags);
+                for (i = 0, data = salinfo_data;
+                     i < ARRAY_SIZE(salinfo_data);
+                     ++i, ++data) {
+                        cpu_set(cpu, data->cpu_event);
+                        salinfo_work_to_do(data);
+                }
+                spin_unlock_irqrestore(&data_saved_lock, flags);
+                break;
+        case CPU_DEAD:
+                spin_lock_irqsave(&data_saved_lock, flags);
+                for (i = 0, data = salinfo_data;
+                     i < ARRAY_SIZE(salinfo_data);
+                     ++i, ++data) {
+                        struct salinfo_data_saved *data_saved;
+                        int j;
+                        for (j = ARRAY_SIZE(data->data_saved) - 1, data_saved = data->data_saved + j;
+                             j >= 0;
+                             --j, --data_saved) {
+                                if (data_saved->buffer && data_saved->cpu == cpu) {
+                                        shift1_data_saved(data, j);
+                                }
+                        }
+                        cpu_clear(cpu, data->cpu_event);
+                }
+                spin_unlock_irqrestore(&data_saved_lock, flags);
+                break;
+        }
+        return NOTIFY_OK;
+}
+
+static struct notifier_block salinfo_cpu_notifier =
+{
+        .notifier_call = salinfo_cpu_callback,
+        .priority = 0,
+};
+#endif  /* CONFIG_HOTPLUG_CPU */
+
 static int __init
 salinfo_init(void)
 {
@@ -557,7 +625,7 @@ salinfo_init(void)
         struct proc_dir_entry **sdir = salinfo_proc_entries; /* keeps track of every entry */
         struct proc_dir_entry *dir, *entry;
         struct salinfo_data *data;
-        int i, j, online;
+        int i, j;
 
         salinfo_dir = proc_mkdir("sal", NULL);
         if (!salinfo_dir)
@@ -572,7 +640,7 @@ salinfo_init(void)
         for (i = 0; i < ARRAY_SIZE(salinfo_log_name); i++) {
                 data = salinfo_data + i;
                 data->type = i;
-                sema_init(&data->sem, 0);
+                init_MUTEX(&data->mutex);
                 dir = proc_mkdir(salinfo_log_name[i], salinfo_dir);
                 if (!dir)
                         continue;
@@ -592,12 +660,8 @@ salinfo_init(void)
                 *sdir++ = entry;
 
                 /* we missed any events before now */
-                online = 0;
-                for_each_online_cpu(j) {
-                        set_bit(j, &data->cpu_event);
-                        ++online;
-                }
-                sema_init(&data->sem, online);
+                for_each_online_cpu(j)
+                        cpu_set(j, data->cpu_event);
 
                 *sdir++ = dir;
         }
@@ -609,6 +673,10 @@ salinfo_init(void)
         salinfo_timer.function = &salinfo_timeout;
         add_timer(&salinfo_timer);
 
+#ifdef  CONFIG_HOTPLUG_CPU
+        register_cpu_notifier(&salinfo_cpu_notifier);
+#endif
+
         return 0;
 }
 
diff --git a/arch/ia64/kernel/traps.c b/arch/ia64/kernel/traps.c
index d3e0ecb56d62..55391901b013 100644
--- a/arch/ia64/kernel/traps.c
+++ b/arch/ia64/kernel/traps.c
@@ -530,12 +530,15 @@ ia64_fault (unsigned long vector, unsigned long isr, unsigned long ifa,
                 if (fsys_mode(current, &regs)) {
                         extern char __kernel_syscall_via_break[];
                         /*
-                         * Got a trap in fsys-mode: Taken Branch Trap and Single Step trap
-                         * need special handling; Debug trap is not supposed to happen.
+                         * Got a trap in fsys-mode: Taken Branch Trap
+                         * and Single Step trap need special handling;
+                         * Debug trap is ignored (we disable it here
+                         * and re-enable it in the lower-privilege trap).
                          */
                         if (unlikely(vector == 29)) {
-                                die("Got debug trap in fsys-mode---not supposed to happen!",
-                                    &regs, 0);
+                                set_thread_flag(TIF_DB_DISABLED);
+                                ia64_psr(&regs)->db = 0;
+                                ia64_psr(&regs)->lp = 1;
                                 return;
                         }
                         /* re-do the system call via break 0x100000: */
@@ -589,10 +592,19 @@ ia64_fault (unsigned long vector, unsigned long isr, unsigned long ifa,
               case 34:
                 if (isr & 0x2) {
                         /* Lower-Privilege Transfer Trap */
+
+                        /* If we disabled debug traps during an fsyscall,
+                         * re-enable them here.
+                         */
+                        if (test_thread_flag(TIF_DB_DISABLED)) {
+                                clear_thread_flag(TIF_DB_DISABLED);
+                                ia64_psr(&regs)->db = 1;
+                        }
+
                         /*
-                         * Just clear PSR.lp and then return immediately: all the
-                         * interesting work (e.g., signal delivery is done in the kernel
-                         * exit path).
+                         * Just clear PSR.lp and then return immediately:
+                         * all the interesting work (e.g., signal delivery)
+                         * is done in the kernel exit path.
                          */
                         ia64_psr(&regs)->lp = 0;
                         return;
diff --git a/arch/ia64/mm/tlb.c b/arch/ia64/mm/tlb.c
index 41105d454423..6a4eec9113e8 100644
--- a/arch/ia64/mm/tlb.c
+++ b/arch/ia64/mm/tlb.c
@@ -90,7 +90,7 @@ ia64_global_tlb_purge (struct mm_struct *mm, unsigned long start,
 {
         static DEFINE_SPINLOCK(ptcg_lock);
 
-        if (mm != current->active_mm) {
+        if (mm != current->active_mm || !current->mm) {
                 flush_tlb_all();
                 return;
         }
diff --git a/arch/ia64/sn/include/xtalk/hubdev.h b/arch/ia64/sn/include/xtalk/hubdev.h
index 71c2b271b4c6..4d417c301201 100644
--- a/arch/ia64/sn/include/xtalk/hubdev.h
+++ b/arch/ia64/sn/include/xtalk/hubdev.h
@@ -26,11 +26,14 @@
 #define IIO_NUM_ITTES   7
 #define HUB_NUM_BIG_WINDOW      (IIO_NUM_ITTES - 1)
 
-struct sn_flush_device_list {
+/* This struct is shared between the PROM and the kernel.
+ * Changes to this struct will require corresponding changes to the kernel.
+ */
+struct sn_flush_device_common {
         int sfdl_bus;
         int sfdl_slot;
         int sfdl_pin;
-        struct bar_list {
+        struct common_bar_list {
                 unsigned long start;
                 unsigned long end;
         } sfdl_bar_list[6];
@@ -40,14 +43,19 @@ struct sn_flush_device_list {
         uint32_t sfdl_persistent_busnum;
         uint32_t sfdl_persistent_segment;
         struct pcibus_info *sfdl_pcibus_info;
+};
+
+/* This struct is kernel only and is not used by the PROM */
+struct sn_flush_device_kernel {
         spinlock_t sfdl_flush_lock;
+        struct sn_flush_device_common *common;
 };
 
 /*
- * **widget_p - Used as an array[wid_num][device] of sn_flush_device_list.
+ * **widget_p - Used as an array[wid_num][device] of sn_flush_device_kernel.
  */
 struct sn_flush_nasid_entry  {
-        struct sn_flush_device_list **widget_p; /* Used as a array of wid_num */
+        struct sn_flush_device_kernel **widget_p; // Used as an array of wid_num
         uint64_t iio_itte[8];
 };
 
diff --git a/arch/ia64/sn/kernel/bte_error.c b/arch/ia64/sn/kernel/bte_error.c
index fcbc748ae433..f1ec1370b3e3 100644
--- a/arch/ia64/sn/kernel/bte_error.c
+++ b/arch/ia64/sn/kernel/bte_error.c
@@ -33,7 +33,7 @@ void bte_error_handler(unsigned long);
  * Wait until all BTE related CRBs are completed
  * and then reset the interfaces.
  */
-void shub1_bte_error_handler(unsigned long _nodepda)
+int shub1_bte_error_handler(unsigned long _nodepda)
 {
         struct nodepda_s *err_nodepda = (struct nodepda_s *)_nodepda;
         struct timer_list *recovery_timer = &err_nodepda->bte_recovery_timer;
@@ -53,7 +53,7 @@ void shub1_bte_error_handler(unsigned long _nodepda)
             (err_nodepda->bte_if[1].bh_error == BTE_SUCCESS)) {
                 BTE_PRINTK(("eh:%p:%d Nothing to do.\n", err_nodepda,
                             smp_processor_id()));
-                return;
+                return 1;
         }
 
         /* Determine information about our hub */
@@ -81,7 +81,7 @@ void shub1_bte_error_handler(unsigned long _nodepda)
                 mod_timer(recovery_timer, HZ * 5);
                 BTE_PRINTK(("eh:%p:%d Marked Giving up\n", err_nodepda,
                             smp_processor_id()));
-                return;
+                return 1;
         }
         if (icmr.ii_icmr_fld_s.i_crb_vld != 0) {
 
@@ -99,7 +99,7 @@ void shub1_bte_error_handler(unsigned long _nodepda)
                                 BTE_PRINTK(("eh:%p:%d Valid %d, Giving up\n",
                                             err_nodepda, smp_processor_id(),
                                             i));
-                                return;
+                                return 1;
                         }
                 }
         }
@@ -124,6 +124,42 @@ void shub1_bte_error_handler(unsigned long _nodepda)
         REMOTE_HUB_S(nasid, IIO_IBCR, ibcr.ii_ibcr_regval);
 
         del_timer(recovery_timer);
+        return 0;
+}
+
+/*
+ * Wait until all BTE related CRBs are completed
+ * and then reset the interfaces.
+ */
+int shub2_bte_error_handler(unsigned long _nodepda)
+{
+        struct nodepda_s *err_nodepda = (struct nodepda_s *)_nodepda;
+        struct timer_list *recovery_timer = &err_nodepda->bte_recovery_timer;
+        struct bteinfo_s *bte;
+        nasid_t nasid;
+        u64 status;
+        int i;
+
+        nasid = cnodeid_to_nasid(err_nodepda->bte_if[0].bte_cnode);
+
+        /*
+         * Verify that all the BTEs are complete
+         */
+        for (i = 0; i < BTES_PER_NODE; i++) {
+                bte = &err_nodepda->bte_if[i];
+                status = BTE_LNSTAT_LOAD(bte);
+                if ((status & IBLS_ERROR) || !(status & IBLS_BUSY))
+                        continue;
+                mod_timer(recovery_timer, HZ * 5);
+                BTE_PRINTK(("eh:%p:%d Marked Giving up\n", err_nodepda,
+                            smp_processor_id()));
+                return 1;
+        }
+        if (ia64_sn_bte_recovery(nasid))
+                panic("bte_error_handler(): Fatal BTE Error");
+
+        del_timer(recovery_timer);
+        return 0;
 }
 
 /*
@@ -135,7 +171,6 @@ void bte_error_handler(unsigned long _nodepda)
         struct nodepda_s *err_nodepda = (struct nodepda_s *)_nodepda;
         spinlock_t *recovery_lock = &err_nodepda->bte_recovery_lock;
         int i;
-        nasid_t nasid;
         unsigned long irq_flags;
         volatile u64 *notify;
         bte_result_t bh_error;
@@ -160,12 +195,15 @@ void bte_error_handler(unsigned long _nodepda)
         }
 
         if (is_shub1()) {
-                shub1_bte_error_handler(_nodepda);
+                if (shub1_bte_error_handler(_nodepda)) {
+                        spin_unlock_irqrestore(recovery_lock, irq_flags);
+                        return;
+                }
         } else {
-                nasid = cnodeid_to_nasid(err_nodepda->bte_if[0].bte_cnode);
-
-                if (ia64_sn_bte_recovery(nasid))
-                        panic("bte_error_handler(): Fatal BTE Error");
+                if (shub2_bte_error_handler(_nodepda)) {
+                        spin_unlock_irqrestore(recovery_lock, irq_flags);
+                        return;
+                }
         }
 
         for (i = 0; i < BTES_PER_NODE; i++) {
diff --git a/arch/ia64/sn/kernel/huberror.c b/arch/ia64/sn/kernel/huberror.c
index 5c5eb01c50f0..56ab6bae00ee 100644
--- a/arch/ia64/sn/kernel/huberror.c
+++ b/arch/ia64/sn/kernel/huberror.c
@@ -32,13 +32,14 @@ static irqreturn_t hub_eint_handler(int irq, void *arg, struct pt_regs *ep)
         ret_stuff.v0 = 0;
         hubdev_info = (struct hubdev_info *)arg;
         nasid = hubdev_info->hdi_nasid;
-        SAL_CALL_NOLOCK(ret_stuff, SN_SAL_HUB_ERROR_INTERRUPT,
+
+        if (is_shub1()) {
+                SAL_CALL_NOLOCK(ret_stuff, SN_SAL_HUB_ERROR_INTERRUPT,
                         (u64) nasid, 0, 0, 0, 0, 0, 0);
 
-        if ((int)ret_stuff.v0)
-                panic("hubii_eint_handler(): Fatal TIO Error");
+                if ((int)ret_stuff.v0)
+                        panic("hubii_eint_handler(): Fatal TIO Error");
 
-        if (is_shub1()) {
                 if (!(nasid & 1)) /* Not a TIO, handle CRB errors */
                         (void)hubiio_crb_error_handler(hubdev_info);
         } else 
diff --git a/arch/ia64/sn/kernel/io_init.c b/arch/ia64/sn/kernel/io_init.c
index 318087e35b66..258d9d7aff98 100644
--- a/arch/ia64/sn/kernel/io_init.c
+++ b/arch/ia64/sn/kernel/io_init.c
@@ -76,11 +76,12 @@ static struct sn_pcibus_provider sn_pci_default_provider = {
 };
 
 /*
- * Retrieve the DMA Flush List given nasid.  This list is needed 
- * to implement the WAR - Flush DMA data on PIO Reads.
+ * Retrieve the DMA Flush List given nasid, widget, and device.
+ * This list is needed to implement the WAR - Flush DMA data on PIO Reads.
  */
-static inline uint64_t
-sal_get_widget_dmaflush_list(u64 nasid, u64 widget_num, u64 address)
+static inline u64
+sal_get_device_dmaflush_list(u64 nasid, u64 widget_num, u64 device_num,
+                             u64 address)
 {
 
         struct ia64_sal_retval ret_stuff;
@@ -88,17 +89,17 @@ sal_get_widget_dmaflush_list(u64 nasid, u64 widget_num, u64 address)
         ret_stuff.v0 = 0;
 
         SAL_CALL_NOLOCK(ret_stuff,
-                        (u64) SN_SAL_IOIF_GET_WIDGET_DMAFLUSH_LIST,
-                        (u64) nasid, (u64) widget_num, (u64) address, 0, 0, 0,
-                        0);
-        return ret_stuff.v0;
+                        (u64) SN_SAL_IOIF_GET_DEVICE_DMAFLUSH_LIST,
+                        (u64) nasid, (u64) widget_num,
+                        (u64) device_num, (u64) address, 0, 0, 0);
+        return ret_stuff.status;
 
 }
 
 /*
  * Retrieve the hub device info structure for the given nasid.
  */
-static inline uint64_t sal_get_hubdev_info(u64 handle, u64 address)
+static inline u64 sal_get_hubdev_info(u64 handle, u64 address)
 {
 
         struct ia64_sal_retval ret_stuff;
@@ -114,7 +115,7 @@ static inline uint64_t sal_get_hubdev_info(u64 handle, u64 address)
 /*
  * Retrieve the pci bus information given the bus number.
  */
-static inline uint64_t sal_get_pcibus_info(u64 segment, u64 busnum, u64 address)
+static inline u64 sal_get_pcibus_info(u64 segment, u64 busnum, u64 address)
 {
 
         struct ia64_sal_retval ret_stuff;
@@ -130,7 +131,7 @@ static inline uint64_t sal_get_pcibus_info(u64 segment, u64 busnum, u64 address)
 /*
  * Retrieve the pci device information given the bus and device|function number.
  */
-static inline uint64_t
+static inline u64
 sal_get_pcidev_info(u64 segment, u64 bus_number, u64 devfn, u64 pci_dev, 
                         u64 sn_irq_info)
 {
@@ -170,12 +171,12 @@ sn_pcidev_info_get(struct pci_dev *dev)
  */
 static void sn_fixup_ionodes(void)
 {
-
-        struct sn_flush_device_list *sn_flush_device_list;
+        struct sn_flush_device_kernel *sn_flush_device_kernel;
+        struct sn_flush_device_kernel *dev_entry;
         struct hubdev_info *hubdev;
-        uint64_t status;
-        uint64_t nasid;
-        int i, widget;
+        u64 status;
+        u64 nasid;
+        int i, widget, device;
 
         /*
          * Get SGI Specific HUB chipset information.
@@ -186,7 +187,7 @@ static void sn_fixup_ionodes(void)
                 nasid = cnodeid_to_nasid(i);
                 hubdev->max_segment_number = 0xffffffff;
                 hubdev->max_pcibus_number = 0xff;
-                status = sal_get_hubdev_info(nasid, (uint64_t) __pa(hubdev));
+                status = sal_get_hubdev_info(nasid, (u64) __pa(hubdev));
                 if (status)
                         continue;
 
@@ -213,38 +214,49 @@ static void sn_fixup_ionodes(void)
 
                 hubdev->hdi_flush_nasid_list.widget_p =
                     kmalloc((HUB_WIDGET_ID_MAX + 1) *
-                            sizeof(struct sn_flush_device_list *), GFP_KERNEL);
-
+                            sizeof(struct sn_flush_device_kernel *),
+                            GFP_KERNEL);
                 memset(hubdev->hdi_flush_nasid_list.widget_p, 0x0,
                        (HUB_WIDGET_ID_MAX + 1) *
-                       sizeof(struct sn_flush_device_list *));
+                       sizeof(struct sn_flush_device_kernel *));
 
                 for (widget = 0; widget <= HUB_WIDGET_ID_MAX; widget++) {
-                        sn_flush_device_list = kmalloc(DEV_PER_WIDGET *
-                                                       sizeof(struct
-                                                              sn_flush_device_list),
-                                                       GFP_KERNEL);
-                        memset(sn_flush_device_list, 0x0,
+                        sn_flush_device_kernel = kmalloc(DEV_PER_WIDGET *
+                                                         sizeof(struct
+                                                        sn_flush_device_kernel),
+                                                        GFP_KERNEL);
+                        if (!sn_flush_device_kernel)
+                                BUG();
+                        memset(sn_flush_device_kernel, 0x0,
                                DEV_PER_WIDGET *
-                               sizeof(struct sn_flush_device_list));
-
-                        status =
-                            sal_get_widget_dmaflush_list(nasid, widget,
-                                                         (uint64_t)
-                                                         __pa
-                                                         (sn_flush_device_list));
-                        if (status) {
-                                kfree(sn_flush_device_list);
-                                continue;
+                               sizeof(struct sn_flush_device_kernel));
+
+                        dev_entry = sn_flush_device_kernel;
+                        for (device = 0; device < DEV_PER_WIDGET;
+                             device++,dev_entry++) {
+                                dev_entry->common = kmalloc(sizeof(struct
+                                                        sn_flush_device_common),
+                                                            GFP_KERNEL);
+                                if (!dev_entry->common)
+                                        BUG();
+                                memset(dev_entry->common, 0x0, sizeof(struct
+                                                       sn_flush_device_common));
+
+                                status = sal_get_device_dmaflush_list(nasid,
+                                                                        widget,
+                                                                        device,
+                                                      (u64)(dev_entry->common));
+                                if (status)
+                                        BUG();
+
+                                spin_lock_init(&dev_entry->sfdl_flush_lock);
                         }
 
-                        spin_lock_init(&sn_flush_device_list->sfdl_flush_lock);
-                        hubdev->hdi_flush_nasid_list.widget_p[widget] =
-                            sn_flush_device_list;
-                }
-
+                        if (sn_flush_device_kernel)
+                                hubdev->hdi_flush_nasid_list.widget_p[widget] =
+                                                       sn_flush_device_kernel;
+                }
         }
-
 }
 
 /*
diff --git a/arch/ia64/sn/kernel/tiocx.c b/arch/ia64/sn/kernel/tiocx.c
index 493fb3f38dc3..6a7939b16a1c 100644
--- a/arch/ia64/sn/kernel/tiocx.c
+++ b/arch/ia64/sn/kernel/tiocx.c
@@ -77,12 +77,6 @@ static void tiocx_bus_release(struct device *dev)
         kfree(to_cx_dev(dev));
 }
 
-struct bus_type tiocx_bus_type = {
-        .name = "tiocx",
-        .match = tiocx_match,
-        .uevent = tiocx_uevent,
-};
-
 /**
  * cx_device_match - Find cx_device in the id table.
  * @ids: id table from driver
@@ -149,6 +143,14 @@ static int cx_driver_remove(struct device *dev)
         return 0;
 }
 
+struct bus_type tiocx_bus_type = {
+        .name = "tiocx",
+        .match = tiocx_match,
+        .uevent = tiocx_uevent,
+        .probe = cx_device_probe,
+        .remove = cx_driver_remove,
+};
+
 /**
  * cx_driver_register - Register the driver.
  * @cx_driver: driver table (cx_drv struct) from driver
@@ -162,8 +164,6 @@ int cx_driver_register(struct cx_drv *cx_driver)
 {
         cx_driver->driver.name = cx_driver->name;
         cx_driver->driver.bus = &tiocx_bus_type;
-        cx_driver->driver.probe = cx_device_probe;
-        cx_driver->driver.remove = cx_driver_remove;
 
         return driver_register(&cx_driver->driver);
 }
diff --git a/arch/ia64/sn/kernel/xpc.h b/arch/ia64/sn/kernel/xpc.h
deleted file mode 100644
index 5483a9f227d4..000000000000
--- a/arch/ia64/sn/kernel/xpc.h
+++ /dev/null
@@ -1,1273 +0,0 @@
-/*
- * This file is subject to the terms and conditions of the GNU General Public
- * License.  See the file "COPYING" in the main directory of this archive
- * for more details.
- *
- * Copyright (c) 2004-2005 Silicon Graphics, Inc.  All Rights Reserved.
- */
-
-
-/*
- * Cross Partition Communication (XPC) structures and macros.
- */
-
-#ifndef _IA64_SN_KERNEL_XPC_H
-#define _IA64_SN_KERNEL_XPC_H
-
-
-#include <linux/config.h>
-#include <linux/interrupt.h>
-#include <linux/sysctl.h>
-#include <linux/device.h>
-#include <asm/pgtable.h>
-#include <asm/processor.h>
-#include <asm/sn/bte.h>
-#include <asm/sn/clksupport.h>
-#include <asm/sn/addrs.h>
-#include <asm/sn/mspec.h>
-#include <asm/sn/shub_mmr.h>
-#include <asm/sn/xp.h>
-
-
-/*
- * XPC Version numbers consist of a major and minor number. XPC can always
- * talk to versions with same major #, and never talk to versions with a
- * different major #.
- */
-#define _XPC_VERSION(_maj, _min)        (((_maj) << 4) | ((_min) & 0xf))
-#define XPC_VERSION_MAJOR(_v)           ((_v) >> 4)
-#define XPC_VERSION_MINOR(_v)           ((_v) & 0xf)
-
-
-/*
- * The next macros define word or bit representations for given
- * C-brick nasid in either the SAL provided bit array representing
- * nasids in the partition/machine or the AMO_t array used for
- * inter-partition initiation communications.
- *
- * For SN2 machines, C-Bricks are alway even numbered NASIDs.  As
- * such, some space will be saved by insisting that nasid information
- * passed from SAL always be packed for C-Bricks and the
- * cross-partition interrupts use the same packing scheme.
- */
-#define XPC_NASID_W_INDEX(_n)   (((_n) / 64) / 2)
-#define XPC_NASID_B_INDEX(_n)   (((_n) / 2) & (64 - 1))
-#define XPC_NASID_IN_ARRAY(_n, _p) ((_p)[XPC_NASID_W_INDEX(_n)] & \
-                                    (1UL << XPC_NASID_B_INDEX(_n)))
-#define XPC_NASID_FROM_W_B(_w, _b) (((_w) * 64 + (_b)) * 2)
-
-#define XPC_HB_DEFAULT_INTERVAL         5       /* incr HB every x secs */
-#define XPC_HB_CHECK_DEFAULT_INTERVAL   20      /* check HB every x secs */
-
-/* define the process name of HB checker and the CPU it is pinned to */
-#define XPC_HB_CHECK_THREAD_NAME        "xpc_hb"
-#define XPC_HB_CHECK_CPU                0
-
-/* define the process name of the discovery thread */
-#define XPC_DISCOVERY_THREAD_NAME       "xpc_discovery"
-
-
-/*
- * the reserved page
- *
- *   SAL reserves one page of memory per partition for XPC. Though a full page
- *   in length (16384 bytes), its starting address is not page aligned, but it
- *   is cacheline aligned. The reserved page consists of the following:
- *
- *   reserved page header
- *
- *     The first cacheline of the reserved page contains the header
- *     (struct xpc_rsvd_page). Before SAL initialization has completed,
- *     SAL has set up the following fields of the reserved page header:
- *     SAL_signature, SAL_version, partid, and nasids_size. The other
- *     fields are set up by XPC. (xpc_rsvd_page points to the local
- *     partition's reserved page.)
- *
- *   part_nasids mask
- *   mach_nasids mask
- *
- *     SAL also sets up two bitmaps (or masks), one that reflects the actual
- *     nasids in this partition (part_nasids), and the other that reflects
- *     the actual nasids in the entire machine (mach_nasids). We're only
- *     interested in the even numbered nasids (which contain the processors
- *     and/or memory), so we only need half as many bits to represent the
- *     nasids. The part_nasids mask is located starting at the first cacheline
- *     following the reserved page header. The mach_nasids mask follows right
- *     after the part_nasids mask. The size in bytes of each mask is reflected
- *     by the reserved page header field 'nasids_size'. (Local partition's
- *     mask pointers are xpc_part_nasids and xpc_mach_nasids.)
- *
- *   vars
- *   vars part
- *
- *     Immediately following the mach_nasids mask are the XPC variables
- *     required by other partitions. First are those that are generic to all
- *     partitions (vars), followed on the next available cacheline by those
- *     which are partition specific (vars part). These are setup by XPC.
- *     (Local partition's vars pointers are xpc_vars and xpc_vars_part.)
- *
- * Note: Until vars_pa is set, the partition XPC code has not been initialized.
- */
-struct xpc_rsvd_page {
-        u64 SAL_signature;      /* SAL: unique signature */
-        u64 SAL_version;        /* SAL: version */
-        u8 partid;              /* SAL: partition ID */
-        u8 version;
-        u8 pad1[6];             /* align to next u64 in cacheline */
-        volatile u64 vars_pa;
-        struct timespec stamp;  /* time when reserved page was setup by XPC */
-        u64 pad2[9];            /* align to last u64 in cacheline */
-        u64 nasids_size;        /* SAL: size of each nasid mask in bytes */
-};
-
-#define XPC_RP_VERSION _XPC_VERSION(1,1) /* version 1.1 of the reserved page */
-
-#define XPC_SUPPORTS_RP_STAMP(_version) \
-                        (_version >= _XPC_VERSION(1,1))
-
-/*
- * compare stamps - the return value is:
- *
- *      < 0,    if stamp1 < stamp2
- *      = 0,    if stamp1 == stamp2
- *      > 0,    if stamp1 > stamp2
- */
-static inline int
-xpc_compare_stamps(struct timespec *stamp1, struct timespec *stamp2)
-{
-        int ret;
-
-
-        if ((ret = stamp1->tv_sec - stamp2->tv_sec) == 0) {
-                ret = stamp1->tv_nsec - stamp2->tv_nsec;
-        }
-        return ret;
-}
-
-
-/*
- * Define the structures by which XPC variables can be exported to other
- * partitions. (There are two: struct xpc_vars and struct xpc_vars_part)
- */
-
-/*
- * The following structure describes the partition generic variables
- * needed by other partitions in order to properly initialize.
- *
- * struct xpc_vars version number also applies to struct xpc_vars_part.
- * Changes to either structure and/or related functionality should be
- * reflected by incrementing either the major or minor version numbers
- * of struct xpc_vars.
- */
-struct xpc_vars {
-        u8 version;
-        u64 heartbeat;
-        u64 heartbeating_to_mask;
-        u64 heartbeat_offline;  /* if 0, heartbeat should be changing */
-        int act_nasid;
-        int act_phys_cpuid;
-        u64 vars_part_pa;
-        u64 amos_page_pa;       /* paddr of page of AMOs from MSPEC driver */
-        AMO_t *amos_page;       /* vaddr of page of AMOs from MSPEC driver */
-};
-
-#define XPC_V_VERSION _XPC_VERSION(3,1) /* version 3.1 of the cross vars */
-
-#define XPC_SUPPORTS_DISENGAGE_REQUEST(_version) \
-                        (_version >= _XPC_VERSION(3,1))
-
-
-static inline int
-xpc_hb_allowed(partid_t partid, struct xpc_vars *vars)
-{
-        return ((vars->heartbeating_to_mask & (1UL << partid)) != 0);
-}
-
-static inline void
-xpc_allow_hb(partid_t partid, struct xpc_vars *vars)
-{
-        u64 old_mask, new_mask;
-
-        do {
-                old_mask = vars->heartbeating_to_mask;
-                new_mask = (old_mask | (1UL << partid));
-        } while (cmpxchg(&vars->heartbeating_to_mask, old_mask, new_mask) !=
-                                                        old_mask);
-}
-
-static inline void
-xpc_disallow_hb(partid_t partid, struct xpc_vars *vars)
-{
-        u64 old_mask, new_mask;
-
-        do {
-                old_mask = vars->heartbeating_to_mask;
-                new_mask = (old_mask & ~(1UL << partid));
-        } while (cmpxchg(&vars->heartbeating_to_mask, old_mask, new_mask) !=
-                                                        old_mask);
-}
-
-
-/*
- * The AMOs page consists of a number of AMO variables which are divided into
- * four groups, The first two groups are used to identify an IRQ's sender.
- * These two groups consist of 64 and 128 AMO variables respectively. The last
- * two groups, consisting of just one AMO variable each, are used to identify
- * the remote partitions that are currently engaged (from the viewpoint of
- * the XPC running on the remote partition).
- */
-#define XPC_NOTIFY_IRQ_AMOS        0
-#define XPC_ACTIVATE_IRQ_AMOS      (XPC_NOTIFY_IRQ_AMOS + XP_MAX_PARTITIONS)
-#define XPC_ENGAGED_PARTITIONS_AMO (XPC_ACTIVATE_IRQ_AMOS + XP_NASID_MASK_WORDS)
-#define XPC_DISENGAGE_REQUEST_AMO  (XPC_ENGAGED_PARTITIONS_AMO + 1)
-
-
-/*
- * The following structure describes the per partition specific variables.
- *
- * An array of these structures, one per partition, will be defined. As a
- * partition becomes active XPC will copy the array entry corresponding to
- * itself from that partition. It is desirable that the size of this
- * structure evenly divide into a cacheline, such that none of the entries
- * in this array crosses a cacheline boundary. As it is now, each entry
- * occupies half a cacheline.
- */
-struct xpc_vars_part {
-        volatile u64 magic;
-
-        u64 openclose_args_pa;  /* physical address of open and close args */
-        u64 GPs_pa;             /* physical address of Get/Put values */
-
-        u64 IPI_amo_pa;         /* physical address of IPI AMO_t structure */
-        int IPI_nasid;          /* nasid of where to send IPIs */
-        int IPI_phys_cpuid;     /* physical CPU ID of where to send IPIs */
-
-        u8 nchannels;           /* #of defined channels supported */
-
-        u8 reserved[23];        /* pad to a full 64 bytes */
-};
-
-/*
- * The vars_part MAGIC numbers play a part in the first contact protocol.
- *
- * MAGIC1 indicates that the per partition specific variables for a remote
- * partition have been initialized by this partition.
- *
- * MAGIC2 indicates that this partition has pulled the remote partititions
- * per partition variables that pertain to this partition.
- */
-#define XPC_VP_MAGIC1   0x0053524156435058L  /* 'XPCVARS\0'L (little endian) */
-#define XPC_VP_MAGIC2   0x0073726176435058L  /* 'XPCvars\0'L (little endian) */
-
-
-/* the reserved page sizes and offsets */
-
-#define XPC_RP_HEADER_SIZE      L1_CACHE_ALIGN(sizeof(struct xpc_rsvd_page))
-#define XPC_RP_VARS_SIZE        L1_CACHE_ALIGN(sizeof(struct xpc_vars))
-
-#define XPC_RP_PART_NASIDS(_rp) (u64 *) ((u8 *) _rp + XPC_RP_HEADER_SIZE)
-#define XPC_RP_MACH_NASIDS(_rp) (XPC_RP_PART_NASIDS(_rp) + xp_nasid_mask_words)
-#define XPC_RP_VARS(_rp)        ((struct xpc_vars *) XPC_RP_MACH_NASIDS(_rp) + xp_nasid_mask_words)
-#define XPC_RP_VARS_PART(_rp)   (struct xpc_vars_part *) ((u8 *) XPC_RP_VARS(rp) + XPC_RP_VARS_SIZE)
-
-
-/*
- * Functions registered by add_timer() or called by kernel_thread() only
- * allow for a single 64-bit argument. The following macros can be used to
- * pack and unpack two (32-bit, 16-bit or 8-bit) arguments into or out from
- * the passed argument.
- */
-#define XPC_PACK_ARGS(_arg1, _arg2) \
-                        ((((u64) _arg1) & 0xffffffff) | \
-                        ((((u64) _arg2) & 0xffffffff) << 32))
-
-#define XPC_UNPACK_ARG1(_args)  (((u64) _args) & 0xffffffff)
-#define XPC_UNPACK_ARG2(_args)  ((((u64) _args) >> 32) & 0xffffffff)
-
-
-
-/*
- * Define a Get/Put value pair (pointers) used with a message queue.
- */
-struct xpc_gp {
-        volatile s64 get;       /* Get value */
-        volatile s64 put;       /* Put value */
-};
-
-#define XPC_GP_SIZE \
-                L1_CACHE_ALIGN(sizeof(struct xpc_gp) * XPC_NCHANNELS)
-
-
-
-/*
- * Define a structure that contains arguments associated with opening and
- * closing a channel.
- */
-struct xpc_openclose_args {
-        u16 reason;             /* reason why channel is closing */
-        u16 msg_size;           /* sizeof each message entry */
-        u16 remote_nentries;    /* #of message entries in remote msg queue */
-        u16 local_nentries;     /* #of message entries in local msg queue */
-        u64 local_msgqueue_pa;  /* physical address of local message queue */
-};
-
-#define XPC_OPENCLOSE_ARGS_SIZE \
-              L1_CACHE_ALIGN(sizeof(struct xpc_openclose_args) * XPC_NCHANNELS)
-
-
-
-/* struct xpc_msg flags */
-
-#define XPC_M_DONE              0x01    /* msg has been received/consumed */
-#define XPC_M_READY             0x02    /* msg is ready to be sent */
-#define XPC_M_INTERRUPT         0x04    /* send interrupt when msg consumed */
-
-
-#define XPC_MSG_ADDRESS(_payload) \
-                ((struct xpc_msg *)((u8 *)(_payload) - XPC_MSG_PAYLOAD_OFFSET))
-
-
-
-/*
- * Defines notify entry.
- *
- * This is used to notify a message's sender that their message was received
- * and consumed by the intended recipient.
- */
-struct xpc_notify {
-        struct semaphore sema;          /* notify semaphore */
-        volatile u8 type;                       /* type of notification */
-
-        /* the following two fields are only used if type == XPC_N_CALL */
-        xpc_notify_func func;           /* user's notify function */
-        void *key;                      /* pointer to user's key */
-};
-
-/* struct xpc_notify type of notification */
-
-#define XPC_N_CALL              0x01    /* notify function provided by user */
-
-
-
-/*
- * Define the structure that manages all the stuff required by a channel. In
- * particular, they are used to manage the messages sent across the channel.
- *
- * This structure is private to a partition, and is NOT shared across the
- * partition boundary.
- *
- * There is an array of these structures for each remote partition. It is
- * allocated at the time a partition becomes active. The array contains one
- * of these structures for each potential channel connection to that partition.
- *
- * Each of these structures manages two message queues (circular buffers).
- * They are allocated at the time a channel connection is made. One of
- * these message queues (local_msgqueue) holds the locally created messages
- * that are destined for the remote partition. The other of these message
- * queues (remote_msgqueue) is a locally cached copy of the remote partition's
- * own local_msgqueue.
- *
- * The following is a description of the Get/Put pointers used to manage these
- * two message queues. Consider the local_msgqueue to be on one partition
- * and the remote_msgqueue to be its cached copy on another partition. A
- * description of what each of the lettered areas contains is included.
- *
- *
- *                     local_msgqueue      remote_msgqueue
- *
- *                        |/////////|      |/////////|
- *    w_remote_GP.get --> +---------+      |/////////|
- *                        |    F    |      |/////////|
- *     remote_GP.get  --> +---------+      +---------+ <-- local_GP->get
- *                        |         |      |         |
- *                        |         |      |    E    |
- *                        |         |      |         |
- *                        |         |      +---------+ <-- w_local_GP.get
- *                        |    B    |      |/////////|
- *                        |         |      |////D////|
- *                        |         |      |/////////|
- *                        |         |      +---------+ <-- w_remote_GP.put
- *                        |         |      |////C////|
- *      local_GP->put --> +---------+      +---------+ <-- remote_GP.put
- *                        |         |      |/////////|
- *                        |    A    |      |/////////|
- *                        |         |      |/////////|
- *     w_local_GP.put --> +---------+      |/////////|
- *                        |/////////|      |/////////|
- *
- *
- *          ( remote_GP.[get|put] are cached copies of the remote
- *            partition's local_GP->[get|put], and thus their values can
- *            lag behind their counterparts on the remote partition. )
- *
- *
- *  A - Messages that have been allocated, but have not yet been sent to the
- *      remote partition.
- *
- *  B - Messages that have been sent, but have not yet been acknowledged by the
- *      remote partition as having been received.
- *
- *  C - Area that needs to be prepared for the copying of sent messages, by
- *      the clearing of the message flags of any previously received messages.
- *
- *  D - Area into which sent messages are to be copied from the remote
- *      partition's local_msgqueue and then delivered to their intended
- *      recipients. [ To allow for a multi-message copy, another pointer
- *      (next_msg_to_pull) has been added to keep track of the next message
- *      number needing to be copied (pulled). It chases after w_remote_GP.put.
- *      Any messages lying between w_local_GP.get and next_msg_to_pull have
- *      been copied and are ready to be delivered. ]
- *
- *  E - Messages that have been copied and delivered, but have not yet been
- *      acknowledged by the recipient as having been received.
- *
- *  F - Messages that have been acknowledged, but XPC has not yet notified the
- *      sender that the message was received by its intended recipient.
- *      This is also an area that needs to be prepared for the allocating of
- *      new messages, by the clearing of the message flags of the acknowledged
- *      messages.
- */
-struct xpc_channel {
-        partid_t partid;                /* ID of remote partition connected */
-        spinlock_t lock;                /* lock for updating this structure */
-        u32 flags;                      /* general flags */
-
-        enum xpc_retval reason;         /* reason why channel is disconnect'g */
-        int reason_line;                /* line# disconnect initiated from */
-
-        u16 number;                     /* channel # */
-
-        u16 msg_size;                   /* sizeof each msg entry */
-        u16 local_nentries;             /* #of msg entries in local msg queue */
-        u16 remote_nentries;            /* #of msg entries in remote msg queue*/
-
-        void *local_msgqueue_base;      /* base address of kmalloc'd space */
-        struct xpc_msg *local_msgqueue; /* local message queue */
-        void *remote_msgqueue_base;     /* base address of kmalloc'd space */
-        struct xpc_msg *remote_msgqueue;/* cached copy of remote partition's */
-                                        /* local message queue */
-        u64 remote_msgqueue_pa;         /* phys addr of remote partition's */
-                                        /* local message queue */
-
-        atomic_t references;            /* #of external references to queues */
-
-        atomic_t n_on_msg_allocate_wq;   /* #on msg allocation wait queue */
-        wait_queue_head_t msg_allocate_wq; /* msg allocation wait queue */
-
-        u8 delayed_IPI_flags;           /* IPI flags received, but delayed */
-                                        /* action until channel disconnected */
-
-        /* queue of msg senders who want to be notified when msg received */
-
-        atomic_t n_to_notify;           /* #of msg senders to notify */
-        struct xpc_notify *notify_queue;/* notify queue for messages sent */
-
-        xpc_channel_func func;          /* user's channel function */
-        void *key;                      /* pointer to user's key */
-
-        struct semaphore msg_to_pull_sema; /* next msg to pull serialization */
-        struct semaphore wdisconnect_sema; /* wait for channel disconnect */
-
-        struct xpc_openclose_args *local_openclose_args; /* args passed on */
-                                        /* opening or closing of channel */
-
-        /* various flavors of local and remote Get/Put values */
-
-        struct xpc_gp *local_GP;        /* local Get/Put values */
-        struct xpc_gp remote_GP;        /* remote Get/Put values */
-        struct xpc_gp w_local_GP;       /* working local Get/Put values */
-        struct xpc_gp w_remote_GP;      /* working remote Get/Put values */
-        s64 next_msg_to_pull;           /* Put value of next msg to pull */
-
-        /* kthread management related fields */
-
-// >>> rethink having kthreads_assigned_limit and kthreads_idle_limit; perhaps
-// >>> allow the assigned limit be unbounded and let the idle limit be dynamic
-// >>> dependent on activity over the last interval of time
-        atomic_t kthreads_assigned;     /* #of kthreads assigned to channel */
-        u32 kthreads_assigned_limit;    /* limit on #of kthreads assigned */
-        atomic_t kthreads_idle;         /* #of kthreads idle waiting for work */
-        u32 kthreads_idle_limit;        /* limit on #of kthreads idle */
-        atomic_t kthreads_active;       /* #of kthreads actively working */
-        // >>> following field is temporary
-        u32 kthreads_created;           /* total #of kthreads created */
-
-        wait_queue_head_t idle_wq;      /* idle kthread wait queue */
-
-} ____cacheline_aligned;
-
-
-/* struct xpc_channel flags */
-
-#define XPC_C_WASCONNECTED      0x00000001 /* channel was connected */
-
-#define XPC_C_ROPENREPLY        0x00000002 /* remote open channel reply */
-#define XPC_C_OPENREPLY         0x00000004 /* local open channel reply */
-#define XPC_C_ROPENREQUEST      0x00000008 /* remote open channel request */
-#define XPC_C_OPENREQUEST       0x00000010 /* local open channel request */
-
-#define XPC_C_SETUP             0x00000020 /* channel's msgqueues are alloc'd */
-#define XPC_C_CONNECTCALLOUT    0x00000040 /* channel connected callout made */
-#define XPC_C_CONNECTED         0x00000080 /* local channel is connected */
-#define XPC_C_CONNECTING        0x00000100 /* channel is being connected */
-
-#define XPC_C_RCLOSEREPLY       0x00000200 /* remote close channel reply */
-#define XPC_C_CLOSEREPLY        0x00000400 /* local close channel reply */
-#define XPC_C_RCLOSEREQUEST     0x00000800 /* remote close channel request */
-#define XPC_C_CLOSEREQUEST      0x00001000 /* local close channel request */
-
-#define XPC_C_DISCONNECTED      0x00002000 /* channel is disconnected */
-#define XPC_C_DISCONNECTING     0x00004000 /* channel is being disconnected */
-#define XPC_C_DISCONNECTCALLOUT 0x00008000 /* chan disconnected callout made */
-#define XPC_C_WDISCONNECT       0x00010000 /* waiting for channel disconnect */
-
-
-
-/*
- * Manages channels on a partition basis. There is one of these structures
- * for each partition (a partition will never utilize the structure that
- * represents itself).
- */
-struct xpc_partition {
-
-        /* XPC HB infrastructure */
-
-        u8 remote_rp_version;           /* version# of partition's rsvd pg */
-        struct timespec remote_rp_stamp;/* time when rsvd pg was initialized */
-        u64 remote_rp_pa;               /* phys addr of partition's rsvd pg */
-        u64 remote_vars_pa;             /* phys addr of partition's vars */
-        u64 remote_vars_part_pa;        /* phys addr of partition's vars part */
-        u64 last_heartbeat;             /* HB at last read */
-        u64 remote_amos_page_pa;        /* phys addr of partition's amos page */
-        int remote_act_nasid;           /* active part's act/deact nasid */
-        int remote_act_phys_cpuid;      /* active part's act/deact phys cpuid */
-        u32 act_IRQ_rcvd;               /* IRQs since activation */
-        spinlock_t act_lock;            /* protect updating of act_state */
-        u8 act_state;                   /* from XPC HB viewpoint */
-        u8 remote_vars_version;         /* version# of partition's vars */
-        enum xpc_retval reason;         /* reason partition is deactivating */
-        int reason_line;                /* line# deactivation initiated from */
-        int reactivate_nasid;           /* nasid in partition to reactivate */
-
-        unsigned long disengage_request_timeout; /* timeout in jiffies */
-        struct timer_list disengage_request_timer;
-
-
-        /* XPC infrastructure referencing and teardown control */
-
-        volatile u8 setup_state;        /* infrastructure setup state */
-        wait_queue_head_t teardown_wq;  /* kthread waiting to teardown infra */
-        atomic_t references;            /* #of references to infrastructure */
-
-
-        /*
-         * NONE OF THE PRECEDING FIELDS OF THIS STRUCTURE WILL BE CLEARED WHEN
-         * XPC SETS UP THE NECESSARY INFRASTRUCTURE TO SUPPORT CROSS PARTITION
-         * COMMUNICATION. ALL OF THE FOLLOWING FIELDS WILL BE CLEARED. (THE
-         * 'nchannels' FIELD MUST BE THE FIRST OF THE FIELDS TO BE CLEARED.)
-         */
-
-
-        u8 nchannels;              /* #of defined channels supported */
-        atomic_t nchannels_active; /* #of channels that are not DISCONNECTED */
-        atomic_t nchannels_engaged;/* #of channels engaged with remote part */
-        struct xpc_channel *channels;/* array of channel structures */
-
-        void *local_GPs_base;     /* base address of kmalloc'd space */
-        struct xpc_gp *local_GPs; /* local Get/Put values */
-        void *remote_GPs_base;    /* base address of kmalloc'd space */
-        struct xpc_gp *remote_GPs;/* copy of remote partition's local Get/Put */
-                                  /* values */
-        u64 remote_GPs_pa;        /* phys address of remote partition's local */
-                                  /* Get/Put values */
-
-
-        /* fields used to pass args when opening or closing a channel */
-
-        void *local_openclose_args_base;  /* base address of kmalloc'd space */
-        struct xpc_openclose_args *local_openclose_args;  /* local's args */
-        void *remote_openclose_args_base; /* base address of kmalloc'd space */
-        struct xpc_openclose_args *remote_openclose_args; /* copy of remote's */
-                                          /* args */
-        u64 remote_openclose_args_pa;     /* phys addr of remote's args */
-
-
-        /* IPI sending, receiving and handling related fields */
-
-        int remote_IPI_nasid;       /* nasid of where to send IPIs */
-        int remote_IPI_phys_cpuid;  /* phys CPU ID of where to send IPIs */
-        AMO_t *remote_IPI_amo_va;   /* address of remote IPI AMO_t structure */
-
-        AMO_t *local_IPI_amo_va;    /* address of IPI AMO_t structure */
-        u64 local_IPI_amo;          /* IPI amo flags yet to be handled */
-        char IPI_owner[8];          /* IPI owner's name */
-        struct timer_list dropped_IPI_timer; /* dropped IPI timer */
-
-        spinlock_t IPI_lock;        /* IPI handler lock */
-
-
-        /* channel manager related fields */
-
-        atomic_t channel_mgr_requests;  /* #of requests to activate chan mgr */
-        wait_queue_head_t channel_mgr_wq; /* channel mgr's wait queue */
-
-} ____cacheline_aligned;
-
-
-/* struct xpc_partition act_state values (for XPC HB) */
-
-#define XPC_P_INACTIVE          0x00    /* partition is not active */
-#define XPC_P_ACTIVATION_REQ    0x01    /* created thread to activate */
-#define XPC_P_ACTIVATING        0x02    /* activation thread started */
-#define XPC_P_ACTIVE            0x03    /* xpc_partition_up() was called */
-#define XPC_P_DEACTIVATING      0x04    /* partition deactivation initiated */
-
-
-#define XPC_DEACTIVATE_PARTITION(_p, _reason) \
-                        xpc_deactivate_partition(__LINE__, (_p), (_reason))
-
-
-/* struct xpc_partition setup_state values */
-
-#define XPC_P_UNSET             0x00    /* infrastructure was never setup */
-#define XPC_P_SETUP             0x01    /* infrastructure is setup */
-#define XPC_P_WTEARDOWN         0x02    /* waiting to teardown infrastructure */
-#define XPC_P_TORNDOWN          0x03    /* infrastructure is torndown */
-
-
-
-/*
- * struct xpc_partition IPI_timer #of seconds to wait before checking for
- * dropped IPIs. These occur whenever an IPI amo write doesn't complete until
- * after the IPI was received.
- */
-#define XPC_P_DROPPED_IPI_WAIT  (0.25 * HZ)
-
-
-/* number of seconds to wait for other partitions to disengage */
-#define XPC_DISENGAGE_REQUEST_DEFAULT_TIMELIMIT 90
-
-/* interval in seconds to print 'waiting disengagement' messages */
-#define XPC_DISENGAGE_PRINTMSG_INTERVAL         10
-
-
-#define XPC_PARTID(_p)  ((partid_t) ((_p) - &xpc_partitions[0]))
-
-
-
-/* found in xp_main.c */
-extern struct xpc_registration xpc_registrations[];
-
-
-/* found in xpc_main.c */
-extern struct device *xpc_part;
-extern struct device *xpc_chan;
-extern int xpc_disengage_request_timelimit;
-extern irqreturn_t xpc_notify_IRQ_handler(int, void *, struct pt_regs *);
-extern void xpc_dropped_IPI_check(struct xpc_partition *);
-extern void xpc_activate_partition(struct xpc_partition *);
-extern void xpc_activate_kthreads(struct xpc_channel *, int);
-extern void xpc_create_kthreads(struct xpc_channel *, int);
-extern void xpc_disconnect_wait(int);
-
-
-/* found in xpc_partition.c */
-extern int xpc_exiting;
-extern struct xpc_vars *xpc_vars;
-extern struct xpc_rsvd_page *xpc_rsvd_page;
-extern struct xpc_vars_part *xpc_vars_part;
-extern struct xpc_partition xpc_partitions[XP_MAX_PARTITIONS + 1];
-extern char xpc_remote_copy_buffer[];
-extern struct xpc_rsvd_page *xpc_rsvd_page_init(void);
-extern void xpc_allow_IPI_ops(void);
-extern void xpc_restrict_IPI_ops(void);
-extern int xpc_identify_act_IRQ_sender(void);
-extern int xpc_partition_disengaged(struct xpc_partition *);
-extern enum xpc_retval xpc_mark_partition_active(struct xpc_partition *);
-extern void xpc_mark_partition_inactive(struct xpc_partition *);
-extern void xpc_discovery(void);
-extern void xpc_check_remote_hb(void);
-extern void xpc_deactivate_partition(const int, struct xpc_partition *,
-                                                enum xpc_retval);
-extern enum xpc_retval xpc_initiate_partid_to_nasids(partid_t, void *);
-
-
-/* found in xpc_channel.c */
-extern void xpc_initiate_connect(int);
-extern void xpc_initiate_disconnect(int);
-extern enum xpc_retval xpc_initiate_allocate(partid_t, int, u32, void **);
-extern enum xpc_retval xpc_initiate_send(partid_t, int, void *);
-extern enum xpc_retval xpc_initiate_send_notify(partid_t, int, void *,
-                                                xpc_notify_func, void *);
-extern void xpc_initiate_received(partid_t, int, void *);
-extern enum xpc_retval xpc_setup_infrastructure(struct xpc_partition *);
-extern enum xpc_retval xpc_pull_remote_vars_part(struct xpc_partition *);
-extern void xpc_process_channel_activity(struct xpc_partition *);
-extern void xpc_connected_callout(struct xpc_channel *);
-extern void xpc_deliver_msg(struct xpc_channel *);
-extern void xpc_disconnect_channel(const int, struct xpc_channel *,
-                                        enum xpc_retval, unsigned long *);
-extern void xpc_disconnecting_callout(struct xpc_channel *);
-extern void xpc_partition_going_down(struct xpc_partition *, enum xpc_retval);
-extern void xpc_teardown_infrastructure(struct xpc_partition *);
-
-
-
-static inline void
-xpc_wakeup_channel_mgr(struct xpc_partition *part)
-{
-        if (atomic_inc_return(&part->channel_mgr_requests) == 1) {
-                wake_up(&part->channel_mgr_wq);
-        }
-}
-
-
-
-/*
- * These next two inlines are used to keep us from tearing down a channel's
- * msg queues while a thread may be referencing them.
- */
-static inline void
-xpc_msgqueue_ref(struct xpc_channel *ch)
-{
-        atomic_inc(&ch->references);
-}
-
-static inline void
-xpc_msgqueue_deref(struct xpc_channel *ch)
-{
-        s32 refs = atomic_dec_return(&ch->references);
-
-        DBUG_ON(refs < 0);
-        if (refs == 0) {
-                xpc_wakeup_channel_mgr(&xpc_partitions[ch->partid]);
-        }
-}
-
-
-
-#define XPC_DISCONNECT_CHANNEL(_ch, _reason, _irqflgs) \
-                xpc_disconnect_channel(__LINE__, _ch, _reason, _irqflgs)
-
-
-/*
- * These two inlines are used to keep us from tearing down a partition's
- * setup infrastructure while a thread may be referencing it.
- */
-static inline void
-xpc_part_deref(struct xpc_partition *part)
-{
-        s32 refs = atomic_dec_return(&part->references);
-
-
-        DBUG_ON(refs < 0);
-        if (refs == 0 && part->setup_state == XPC_P_WTEARDOWN) {
-                wake_up(&part->teardown_wq);
-        }
-}
-
-static inline int
-xpc_part_ref(struct xpc_partition *part)
-{
-        int setup;
-
-
-        atomic_inc(&part->references);
-        setup = (part->setup_state == XPC_P_SETUP);
-        if (!setup) {
-                xpc_part_deref(part);
-        }
-        return setup;
-}
-
-
-
-/*
- * The following macro is to be used for the setting of the reason and
- * reason_line fields in both the struct xpc_channel and struct xpc_partition
- * structures.
- */
-#define XPC_SET_REASON(_p, _reason, _line) \
-        { \
-                (_p)->reason = _reason; \
-                (_p)->reason_line = _line; \
-        }
-
-
-
-/*
- * This next set of inlines are used to keep track of when a partition is
- * potentially engaged in accessing memory belonging to another partition.
- */
-
-static inline void
-xpc_mark_partition_engaged(struct xpc_partition *part)
-{
-        unsigned long irq_flags;
-        AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa +
-                                (XPC_ENGAGED_PARTITIONS_AMO * sizeof(AMO_t)));
-
-
-        local_irq_save(irq_flags);
-
-        /* set bit corresponding to our partid in remote partition's AMO */
-        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_OR,
-                                                (1UL << sn_partition_id));
-        /*
-         * We must always use the nofault function regardless of whether we
-         * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we
-         * didn't, we'd never know that the other partition is down and would
-         * keep sending IPIs and AMOs to it until the heartbeat times out.
-         */
-        (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo->
-                                variable), xp_nofault_PIOR_target));
-
-        local_irq_restore(irq_flags);
-}
-
-static inline void
-xpc_mark_partition_disengaged(struct xpc_partition *part)
-{
-        unsigned long irq_flags;
-        AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa +
-                                (XPC_ENGAGED_PARTITIONS_AMO * sizeof(AMO_t)));
-
-
-        local_irq_save(irq_flags);
-
-        /* clear bit corresponding to our partid in remote partition's AMO */
-        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND,
-                                                ~(1UL << sn_partition_id));
-        /*
-         * We must always use the nofault function regardless of whether we
-         * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we
-         * didn't, we'd never know that the other partition is down and would
-         * keep sending IPIs and AMOs to it until the heartbeat times out.
-         */
-        (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo->
-                                variable), xp_nofault_PIOR_target));
-
-        local_irq_restore(irq_flags);
-}
-
-static inline void
-xpc_request_partition_disengage(struct xpc_partition *part)
-{
-        unsigned long irq_flags;
-        AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa +
-                                (XPC_DISENGAGE_REQUEST_AMO * sizeof(AMO_t)));
-
-
-        local_irq_save(irq_flags);
-
-        /* set bit corresponding to our partid in remote partition's AMO */
-        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_OR,
-                                                (1UL << sn_partition_id));
-        /*
-         * We must always use the nofault function regardless of whether we
-         * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we
-         * didn't, we'd never know that the other partition is down and would
-         * keep sending IPIs and AMOs to it until the heartbeat times out.
-         */
-        (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo->
-                                variable), xp_nofault_PIOR_target));
-
-        local_irq_restore(irq_flags);
-}
-
-static inline void
-xpc_cancel_partition_disengage_request(struct xpc_partition *part)
-{
-        unsigned long irq_flags;
-        AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa +
-                                (XPC_DISENGAGE_REQUEST_AMO * sizeof(AMO_t)));
-
-
-        local_irq_save(irq_flags);
-
-        /* clear bit corresponding to our partid in remote partition's AMO */
-        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND,
-                                                ~(1UL << sn_partition_id));
-        /*
-         * We must always use the nofault function regardless of whether we
-         * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we
-         * didn't, we'd never know that the other partition is down and would
-         * keep sending IPIs and AMOs to it until the heartbeat times out.
-         */
-        (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo->
-                                variable), xp_nofault_PIOR_target));
-
-        local_irq_restore(irq_flags);
-}
-
-static inline u64
-xpc_partition_engaged(u64 partid_mask)
-{
-        AMO_t *amo = xpc_vars->amos_page + XPC_ENGAGED_PARTITIONS_AMO;
-
-
-        /* return our partition's AMO variable ANDed with partid_mask */
-        return (FETCHOP_LOAD_OP(TO_AMO((u64) &amo->variable), FETCHOP_LOAD) &
-                                                                partid_mask);
-}
-
-static inline u64
-xpc_partition_disengage_requested(u64 partid_mask)
-{
-        AMO_t *amo = xpc_vars->amos_page + XPC_DISENGAGE_REQUEST_AMO;
-
-
-        /* return our partition's AMO variable ANDed with partid_mask */
-        return (FETCHOP_LOAD_OP(TO_AMO((u64) &amo->variable), FETCHOP_LOAD) &
-                                                                partid_mask);
-}
-
-static inline void
-xpc_clear_partition_engaged(u64 partid_mask)
-{
-        AMO_t *amo = xpc_vars->amos_page + XPC_ENGAGED_PARTITIONS_AMO;
-
-
-        /* clear bit(s) based on partid_mask in our partition's AMO */
-        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND,
-                                                                ~partid_mask);
-}
-
-static inline void
-xpc_clear_partition_disengage_request(u64 partid_mask)
-{
-        AMO_t *amo = xpc_vars->amos_page + XPC_DISENGAGE_REQUEST_AMO;
-
-
-        /* clear bit(s) based on partid_mask in our partition's AMO */
-        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND,
-                                                                ~partid_mask);
-}
-
-
-
-/*
- * The following set of macros and inlines are used for the sending and
- * receiving of IPIs (also known as IRQs). There are two flavors of IPIs,
- * one that is associated with partition activity (SGI_XPC_ACTIVATE) and
- * the other that is associated with channel activity (SGI_XPC_NOTIFY).
- */
-
-static inline u64
-xpc_IPI_receive(AMO_t *amo)
-{
-        return FETCHOP_LOAD_OP(TO_AMO((u64) &amo->variable), FETCHOP_CLEAR);
-}
-
-
-static inline enum xpc_retval
-xpc_IPI_send(AMO_t *amo, u64 flag, int nasid, int phys_cpuid, int vector)
-{
-        int ret = 0;
-        unsigned long irq_flags;
-
-
-        local_irq_save(irq_flags);
-
-        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_OR, flag);
-        sn_send_IPI_phys(nasid, phys_cpuid, vector, 0);
-
-        /*
-         * We must always use the nofault function regardless of whether we
-         * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we
-         * didn't, we'd never know that the other partition is down and would
-         * keep sending IPIs and AMOs to it until the heartbeat times out.
-         */
-        ret = xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo->variable),
-                                xp_nofault_PIOR_target));
-
-        local_irq_restore(irq_flags);
-
-        return ((ret == 0) ? xpcSuccess : xpcPioReadError);
-}
-
-
-/*
- * IPIs associated with SGI_XPC_ACTIVATE IRQ.
- */
-
-/*
- * Flag the appropriate AMO variable and send an IPI to the specified node.
- */
-static inline void
-xpc_activate_IRQ_send(u64 amos_page_pa, int from_nasid, int to_nasid,
-                        int to_phys_cpuid)
-{
-        int w_index = XPC_NASID_W_INDEX(from_nasid);
-        int b_index = XPC_NASID_B_INDEX(from_nasid);
-        AMO_t *amos = (AMO_t *) __va(amos_page_pa +
-                                (XPC_ACTIVATE_IRQ_AMOS * sizeof(AMO_t)));
-
-
-        (void) xpc_IPI_send(&amos[w_index], (1UL << b_index), to_nasid,
-                                to_phys_cpuid, SGI_XPC_ACTIVATE);
-}
-
-static inline void
-xpc_IPI_send_activate(struct xpc_vars *vars)
-{
-        xpc_activate_IRQ_send(vars->amos_page_pa, cnodeid_to_nasid(0),
-                                vars->act_nasid, vars->act_phys_cpuid);
-}
-
-static inline void
-xpc_IPI_send_activated(struct xpc_partition *part)
-{
-        xpc_activate_IRQ_send(part->remote_amos_page_pa, cnodeid_to_nasid(0),
-                        part->remote_act_nasid, part->remote_act_phys_cpuid);
-}
-
-static inline void
-xpc_IPI_send_reactivate(struct xpc_partition *part)
-{
-        xpc_activate_IRQ_send(xpc_vars->amos_page_pa, part->reactivate_nasid,
-                                xpc_vars->act_nasid, xpc_vars->act_phys_cpuid);
-}
-
-static inline void
-xpc_IPI_send_disengage(struct xpc_partition *part)
-{
-        xpc_activate_IRQ_send(part->remote_amos_page_pa, cnodeid_to_nasid(0),
-                        part->remote_act_nasid, part->remote_act_phys_cpuid);
-}
-
-
-/*
- * IPIs associated with SGI_XPC_NOTIFY IRQ.
- */
-
-/*
- * Send an IPI to the remote partition that is associated with the
- * specified channel.
- */
-#define XPC_NOTIFY_IRQ_SEND(_ch, _ipi_f, _irq_f) \
-                xpc_notify_IRQ_send(_ch, _ipi_f, #_ipi_f, _irq_f)
-
-static inline void
-xpc_notify_IRQ_send(struct xpc_channel *ch, u8 ipi_flag, char *ipi_flag_string,
-                        unsigned long *irq_flags)
-{
-        struct xpc_partition *part = &xpc_partitions[ch->partid];
-        enum xpc_retval ret;
-
-
-        if (likely(part->act_state != XPC_P_DEACTIVATING)) {
-                ret = xpc_IPI_send(part->remote_IPI_amo_va,
-                                        (u64) ipi_flag << (ch->number * 8),
-                                        part->remote_IPI_nasid,
-                                        part->remote_IPI_phys_cpuid,
-                                        SGI_XPC_NOTIFY);
-                dev_dbg(xpc_chan, "%s sent to partid=%d, channel=%d, ret=%d\n",
-                        ipi_flag_string, ch->partid, ch->number, ret);
-                if (unlikely(ret != xpcSuccess)) {
-                        if (irq_flags != NULL) {
-                                spin_unlock_irqrestore(&ch->lock, *irq_flags);
-                        }
-                        XPC_DEACTIVATE_PARTITION(part, ret);
-                        if (irq_flags != NULL) {
-                                spin_lock_irqsave(&ch->lock, *irq_flags);
-                        }
-                }
-        }
-}
-
-
-/*
- * Make it look like the remote partition, which is associated with the
- * specified channel, sent us an IPI. This faked IPI will be handled
- * by xpc_dropped_IPI_check().
- */
-#define XPC_NOTIFY_IRQ_SEND_LOCAL(_ch, _ipi_f) \
-                xpc_notify_IRQ_send_local(_ch, _ipi_f, #_ipi_f)
-
-static inline void
-xpc_notify_IRQ_send_local(struct xpc_channel *ch, u8 ipi_flag,
-                                char *ipi_flag_string)
-{
-        struct xpc_partition *part = &xpc_partitions[ch->partid];
-
-
-        FETCHOP_STORE_OP(TO_AMO((u64) &part->local_IPI_amo_va->variable),
-                        FETCHOP_OR, ((u64) ipi_flag << (ch->number * 8)));
-        dev_dbg(xpc_chan, "%s sent local from partid=%d, channel=%d\n",
-                ipi_flag_string, ch->partid, ch->number);
-}
-
-
-/*
- * The sending and receiving of IPIs includes the setting of an AMO variable
- * to indicate the reason the IPI was sent. The 64-bit variable is divided
- * up into eight bytes, ordered from right to left. Byte zero pertains to
- * channel 0, byte one to channel 1, and so on. Each byte is described by
- * the following IPI flags.
- */
-
-#define XPC_IPI_CLOSEREQUEST    0x01
-#define XPC_IPI_CLOSEREPLY      0x02
-#define XPC_IPI_OPENREQUEST     0x04
-#define XPC_IPI_OPENREPLY       0x08
-#define XPC_IPI_MSGREQUEST      0x10
-
-
-/* given an AMO variable and a channel#, get its associated IPI flags */
-#define XPC_GET_IPI_FLAGS(_amo, _c)     ((u8) (((_amo) >> ((_c) * 8)) & 0xff))
-#define XPC_SET_IPI_FLAGS(_amo, _c, _f) (_amo) |= ((u64) (_f) << ((_c) * 8))
-
-#define XPC_ANY_OPENCLOSE_IPI_FLAGS_SET(_amo) ((_amo) & 0x0f0f0f0f0f0f0f0f)
-#define XPC_ANY_MSG_IPI_FLAGS_SET(_amo)       ((_amo) & 0x1010101010101010)
-
-
-static inline void
-xpc_IPI_send_closerequest(struct xpc_channel *ch, unsigned long *irq_flags)
-{
-        struct xpc_openclose_args *args = ch->local_openclose_args;
-
-
-        args->reason = ch->reason;
-
-        XPC_NOTIFY_IRQ_SEND(ch, XPC_IPI_CLOSEREQUEST, irq_flags);
-}
-
-static inline void
-xpc_IPI_send_closereply(struct xpc_channel *ch, unsigned long *irq_flags)
-{
-        XPC_NOTIFY_IRQ_SEND(ch, XPC_IPI_CLOSEREPLY, irq_flags);
-}
-
-static inline void
-xpc_IPI_send_openrequest(struct xpc_channel *ch, unsigned long *irq_flags)
-{
-        struct xpc_openclose_args *args = ch->local_openclose_args;
-
-
-        args->msg_size = ch->msg_size;
-        args->local_nentries = ch->local_nentries;
-
-        XPC_NOTIFY_IRQ_SEND(ch, XPC_IPI_OPENREQUEST, irq_flags);
-}
-
-static inline void
-xpc_IPI_send_openreply(struct xpc_channel *ch, unsigned long *irq_flags)
-{
-        struct xpc_openclose_args *args = ch->local_openclose_args;
-
-
-        args->remote_nentries = ch->remote_nentries;
-        args->local_nentries = ch->local_nentries;
-        args->local_msgqueue_pa = __pa(ch->local_msgqueue);
-
-        XPC_NOTIFY_IRQ_SEND(ch, XPC_IPI_OPENREPLY, irq_flags);
-}
-
-static inline void
-xpc_IPI_send_msgrequest(struct xpc_channel *ch)
-{
-        XPC_NOTIFY_IRQ_SEND(ch, XPC_IPI_MSGREQUEST, NULL);
-}
-
-static inline void
-xpc_IPI_send_local_msgrequest(struct xpc_channel *ch)
-{
-        XPC_NOTIFY_IRQ_SEND_LOCAL(ch, XPC_IPI_MSGREQUEST);
-}
-
-
-/*
- * Memory for XPC's AMO variables is allocated by the MSPEC driver. These
- * pages are located in the lowest granule. The lowest granule uses 4k pages
- * for cached references and an alternate TLB handler to never provide a
- * cacheable mapping for the entire region. This will prevent speculative
- * reading of cached copies of our lines from being issued which will cause
- * a PI FSB Protocol error to be generated by the SHUB. For XPC, we need 64
- * AMO variables (based on XP_MAX_PARTITIONS) for message notification and an
- * additional 128 AMO variables (based on XP_NASID_MASK_WORDS) for partition
- * activation and 2 AMO variables for partition deactivation.
- */
-static inline AMO_t *
-xpc_IPI_init(int index)
-{
-        AMO_t *amo = xpc_vars->amos_page + index;
-
-
-        (void) xpc_IPI_receive(amo);    /* clear AMO variable */
-        return amo;
-}
-
-
-
-static inline enum xpc_retval
-xpc_map_bte_errors(bte_result_t error)
-{
-        switch (error) {
-        case BTE_SUCCESS:       return xpcSuccess;
-        case BTEFAIL_DIR:       return xpcBteDirectoryError;
-        case BTEFAIL_POISON:    return xpcBtePoisonError;
-        case BTEFAIL_WERR:      return xpcBteWriteError;
-        case BTEFAIL_ACCESS:    return xpcBteAccessError;
-        case BTEFAIL_PWERR:     return xpcBtePWriteError;
-        case BTEFAIL_PRERR:     return xpcBtePReadError;
-        case BTEFAIL_TOUT:      return xpcBteTimeOutError;
-        case BTEFAIL_XTERR:     return xpcBteXtalkError;
-        case BTEFAIL_NOTAVAIL:  return xpcBteNotAvailable;
-        default:                return xpcBteUnmappedError;
-        }
-}
-
-
-
-static inline void *
-xpc_kmalloc_cacheline_aligned(size_t size, gfp_t flags, void **base)
-{
-        /* see if kmalloc will give us cachline aligned memory by default */
-        *base = kmalloc(size, flags);
-        if (*base == NULL) {
-                return NULL;
-        }
-        if ((u64) *base == L1_CACHE_ALIGN((u64) *base)) {
-                return *base;
-        }
-        kfree(*base);
-
-        /* nope, we'll have to do it ourselves */
-        *base = kmalloc(size + L1_CACHE_BYTES, flags);
-        if (*base == NULL) {
-                return NULL;
-        }
-        return (void *) L1_CACHE_ALIGN((u64) *base);
-}
-
-
-/*
- * Check to see if there is any channel activity to/from the specified
- * partition.
- */
-static inline void
-xpc_check_for_channel_activity(struct xpc_partition *part)
-{
-        u64 IPI_amo;
-        unsigned long irq_flags;
-
-
-        IPI_amo = xpc_IPI_receive(part->local_IPI_amo_va);
-        if (IPI_amo == 0) {
-                return;
-        }
-
-        spin_lock_irqsave(&part->IPI_lock, irq_flags);
-        part->local_IPI_amo |= IPI_amo;
-        spin_unlock_irqrestore(&part->IPI_lock, irq_flags);
-
-        dev_dbg(xpc_chan, "received IPI from partid=%d, IPI_amo=0x%lx\n",
-                XPC_PARTID(part), IPI_amo);
-
-        xpc_wakeup_channel_mgr(part);
-}
-
-
-#endif /* _IA64_SN_KERNEL_XPC_H */
-
diff --git a/arch/ia64/sn/kernel/xpc_channel.c b/arch/ia64/sn/kernel/xpc_channel.c
index abf4fc2a87bb..0c0a68902409 100644
--- a/arch/ia64/sn/kernel/xpc_channel.c
+++ b/arch/ia64/sn/kernel/xpc_channel.c
@@ -3,7 +3,7 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (c) 2004-2005 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2004-2006 Silicon Graphics, Inc.  All Rights Reserved.
  */
 
 
@@ -24,7 +24,7 @@
 #include <linux/slab.h>
 #include <asm/sn/bte.h>
 #include <asm/sn/sn_sal.h>
-#include "xpc.h"
+#include <asm/sn/xpc.h>
 
 
 /*
@@ -779,6 +779,12 @@ xpc_process_disconnect(struct xpc_channel *ch, unsigned long *irq_flags)
 
         /* both sides are disconnected now */
 
+        if (ch->flags & XPC_C_CONNECTCALLOUT) {
+                spin_unlock_irqrestore(&ch->lock, *irq_flags);
+                xpc_disconnect_callout(ch, xpcDisconnected);
+                spin_lock_irqsave(&ch->lock, *irq_flags);
+        }
+
         /* it's now safe to free the channel's message queues */
         xpc_free_msgqueues(ch);
 
@@ -1645,7 +1651,7 @@ xpc_disconnect_channel(const int line, struct xpc_channel *ch,
 
 
 void
-xpc_disconnecting_callout(struct xpc_channel *ch)
+xpc_disconnect_callout(struct xpc_channel *ch, enum xpc_retval reason)
 {
         /*
          * Let the channel's registerer know that the channel is being
@@ -1654,15 +1660,13 @@ xpc_disconnecting_callout(struct xpc_channel *ch)
          */
 
         if (ch->func != NULL) {
-                dev_dbg(xpc_chan, "ch->func() called, reason=xpcDisconnecting,"
-                        " partid=%d, channel=%d\n", ch->partid, ch->number);
+                dev_dbg(xpc_chan, "ch->func() called, reason=%d, partid=%d, "
+                        "channel=%d\n", reason, ch->partid, ch->number);
 
-                ch->func(xpcDisconnecting, ch->partid, ch->number, NULL,
-                                                                ch->key);
+                ch->func(reason, ch->partid, ch->number, NULL, ch->key);
 
-                dev_dbg(xpc_chan, "ch->func() returned, reason="
-                        "xpcDisconnecting, partid=%d, channel=%d\n",
-                        ch->partid, ch->number);
+                dev_dbg(xpc_chan, "ch->func() returned, reason=%d, partid=%d, "
+                        "channel=%d\n", reason, ch->partid, ch->number);
         }
 }
 
diff --git a/arch/ia64/sn/kernel/xpc_main.c b/arch/ia64/sn/kernel/xpc_main.c
index b617236524c6..8930586e0eb4 100644
--- a/arch/ia64/sn/kernel/xpc_main.c
+++ b/arch/ia64/sn/kernel/xpc_main.c
@@ -3,7 +3,7 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (c) 2004-2005 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2004-2006 Silicon Graphics, Inc.  All Rights Reserved.
  */
 
 
@@ -59,7 +59,7 @@
 #include <asm/sn/sn_sal.h>
 #include <asm/kdebug.h>
 #include <asm/uaccess.h>
-#include "xpc.h"
+#include <asm/sn/xpc.h>
 
 
 /* define two XPC debug device structures to be used with dev_dbg() et al */
@@ -82,6 +82,9 @@ struct device *xpc_part = &xpc_part_dbg_subname;
 struct device *xpc_chan = &xpc_chan_dbg_subname;
 
 
+static int xpc_kdebug_ignore;
+
+
 /* systune related variables for /proc/sys directories */
 
 static int xpc_hb_interval = XPC_HB_DEFAULT_INTERVAL;
@@ -162,6 +165,8 @@ static ctl_table xpc_sys_dir[] = {
 };
 static struct ctl_table_header *xpc_sysctl;
 
+/* non-zero if any remote partition disengage request was timed out */
+int xpc_disengage_request_timedout;
 
 /* #of IRQs received */
 static atomic_t xpc_act_IRQ_rcvd;
@@ -773,7 +778,7 @@ xpc_daemonize_kthread(void *args)
                         ch->flags |= XPC_C_DISCONNECTCALLOUT;
                         spin_unlock_irqrestore(&ch->lock, irq_flags);
 
-                        xpc_disconnecting_callout(ch);
+                        xpc_disconnect_callout(ch, xpcDisconnecting);
                 } else {
                         spin_unlock_irqrestore(&ch->lock, irq_flags);
                 }
@@ -921,9 +926,9 @@ static void
 xpc_do_exit(enum xpc_retval reason)
 {
         partid_t partid;
-        int active_part_count;
+        int active_part_count, printed_waiting_msg = 0;
         struct xpc_partition *part;
-        unsigned long printmsg_time;
+        unsigned long printmsg_time, disengage_request_timeout = 0;
 
 
         /* a 'rmmod XPC' and a 'reboot' cannot both end up here together */
@@ -953,7 +958,8 @@ xpc_do_exit(enum xpc_retval reason)
 
         /* wait for all partitions to become inactive */
 
-        printmsg_time = jiffies;
+        printmsg_time = jiffies + (XPC_DISENGAGE_PRINTMSG_INTERVAL * HZ);
+        xpc_disengage_request_timedout = 0;
 
         do {
                 active_part_count = 0;
@@ -969,20 +975,39 @@ xpc_do_exit(enum xpc_retval reason)
                         active_part_count++;
 
                         XPC_DEACTIVATE_PARTITION(part, reason);
-                }
 
-                if (active_part_count == 0) {
-                        break;
+                        if (part->disengage_request_timeout >
+                                                disengage_request_timeout) {
+                                disengage_request_timeout =
+                                                part->disengage_request_timeout;
+                        }
                 }
 
-                if (jiffies >= printmsg_time) {
-                        dev_info(xpc_part, "waiting for partitions to "
-                                "deactivate/disengage, active count=%d, remote "
-                                "engaged=0x%lx\n", active_part_count,
-                                xpc_partition_engaged(1UL << partid));
-
-                        printmsg_time = jiffies +
+                if (xpc_partition_engaged(-1UL)) {
+                        if (time_after(jiffies, printmsg_time)) {
+                                dev_info(xpc_part, "waiting for remote "
+                                        "partitions to disengage, timeout in "
+                                        "%ld seconds\n",
+                                        (disengage_request_timeout - jiffies)
+                                                                        / HZ);
+                                printmsg_time = jiffies +
                                         (XPC_DISENGAGE_PRINTMSG_INTERVAL * HZ);
+                                printed_waiting_msg = 1;
+                        }
+
+                } else if (active_part_count > 0) {
+                        if (printed_waiting_msg) {
+                                dev_info(xpc_part, "waiting for local partition"
+                                        " to disengage\n");
+                                printed_waiting_msg = 0;
+                        }
+
+                } else {
+                        if (!xpc_disengage_request_timedout) {
+                                dev_info(xpc_part, "all partitions have "
+                                        "disengaged\n");
+                        }
+                        break;
                 }
 
                 /* sleep for a 1/3 of a second or so */
@@ -1000,11 +1025,13 @@ xpc_do_exit(enum xpc_retval reason)
         del_timer_sync(&xpc_hb_timer);
         DBUG_ON(xpc_vars->heartbeating_to_mask != 0);
 
-        /* take ourselves off of the reboot_notifier_list */
-        (void) unregister_reboot_notifier(&xpc_reboot_notifier);
+        if (reason == xpcUnloading) {
+                /* take ourselves off of the reboot_notifier_list */
+                (void) unregister_reboot_notifier(&xpc_reboot_notifier);
 
-        /* take ourselves off of the die_notifier list */
-        (void) unregister_die_notifier(&xpc_die_notifier);
+                /* take ourselves off of the die_notifier list */
+                (void) unregister_die_notifier(&xpc_die_notifier);
+        }
 
         /* close down protections for IPI operations */
         xpc_restrict_IPI_ops();
@@ -1020,7 +1047,35 @@ xpc_do_exit(enum xpc_retval reason)
 
 
 /*
- * Called when the system is about to be either restarted or halted.
+ * This function is called when the system is being rebooted.
+ */
+static int
+xpc_system_reboot(struct notifier_block *nb, unsigned long event, void *unused)
+{
+        enum xpc_retval reason;
+
+
+        switch (event) {
+        case SYS_RESTART:
+                reason = xpcSystemReboot;
+                break;
+        case SYS_HALT:
+                reason = xpcSystemHalt;
+                break;
+        case SYS_POWER_OFF:
+                reason = xpcSystemPoweroff;
+                break;
+        default:
+                reason = xpcSystemGoingDown;
+        }
+
+        xpc_do_exit(reason);
+        return NOTIFY_DONE;
+}
+
+
+/*
+ * Notify other partitions to disengage from all references to our memory.
  */
 static void
 xpc_die_disengage(void)
@@ -1028,7 +1083,7 @@ xpc_die_disengage(void)
         struct xpc_partition *part;
         partid_t partid;
         unsigned long engaged;
-        long time, print_time, disengage_request_timeout;
+        long time, printmsg_time, disengage_request_timeout;
 
 
         /* keep xpc_hb_checker thread from doing anything (just in case) */
@@ -1055,57 +1110,53 @@ xpc_die_disengage(void)
                 }
         }
 
-        print_time = rtc_time();
-        disengage_request_timeout = print_time +
+        time = rtc_time();
+        printmsg_time = time +
+                (XPC_DISENGAGE_PRINTMSG_INTERVAL * sn_rtc_cycles_per_second);
+        disengage_request_timeout = time +
                 (xpc_disengage_request_timelimit * sn_rtc_cycles_per_second);
 
         /* wait for all other partitions to disengage from us */
 
-        while ((engaged = xpc_partition_engaged(-1UL)) &&
-                        (time = rtc_time()) < disengage_request_timeout) {
+        while (1) {
+                engaged = xpc_partition_engaged(-1UL);
+                if (!engaged) {
+                        dev_info(xpc_part, "all partitions have disengaged\n");
+                        break;
+                }
 
-                if (time >= print_time) {
+                time = rtc_time();
+                if (time >= disengage_request_timeout) {
+                        for (partid = 1; partid < XP_MAX_PARTITIONS; partid++) {
+                                if (engaged & (1UL << partid)) {
+                                        dev_info(xpc_part, "disengage from "
+                                                "remote partition %d timed "
+                                                "out\n", partid);
+                                }
+                        }
+                        break;
+                }
+
+                if (time >= printmsg_time) {
                         dev_info(xpc_part, "waiting for remote partitions to "
-                                "disengage, engaged=0x%lx\n", engaged);
-                        print_time = time + (XPC_DISENGAGE_PRINTMSG_INTERVAL *
+                                "disengage, timeout in %ld seconds\n",
+                                (disengage_request_timeout - time) /
+                                                sn_rtc_cycles_per_second);
+                        printmsg_time = time +
+                                        (XPC_DISENGAGE_PRINTMSG_INTERVAL *
                                                 sn_rtc_cycles_per_second);
                 }
         }
-        dev_info(xpc_part, "finished waiting for remote partitions to "
-                                "disengage, engaged=0x%lx\n", engaged);
-}
-
-
-/*
- * This function is called when the system is being rebooted.
- */
-static int
-xpc_system_reboot(struct notifier_block *nb, unsigned long event, void *unused)
-{
-        enum xpc_retval reason;
-
-
-        switch (event) {
-        case SYS_RESTART:
-                reason = xpcSystemReboot;
-                break;
-        case SYS_HALT:
-                reason = xpcSystemHalt;
-                break;
-        case SYS_POWER_OFF:
-                reason = xpcSystemPoweroff;
-                break;
-        default:
-                reason = xpcSystemGoingDown;
-        }
-
-        xpc_do_exit(reason);
-        return NOTIFY_DONE;
 }
 
 
 /*
- * This function is called when the system is being rebooted.
+ * This function is called when the system is being restarted or halted due
+ * to some sort of system failure. If this is the case we need to notify the
+ * other partitions to disengage from all references to our memory.
+ * This function can also be called when our heartbeater could be offlined
+ * for a time. In this case we need to notify other partitions to not worry
+ * about the lack of a heartbeat.
  */
 static int
 xpc_system_die(struct notifier_block *nb, unsigned long event, void *unused)
@@ -1115,11 +1166,25 @@ xpc_system_die(struct notifier_block *nb, unsigned long event, void *unused)
         case DIE_MACHINE_HALT:
                 xpc_die_disengage();
                 break;
+
+        case DIE_KDEBUG_ENTER:
+                /* Should lack of heartbeat be ignored by other partitions? */
+                if (!xpc_kdebug_ignore) {
+                        break;
+                }
+                /* fall through */
         case DIE_MCA_MONARCH_ENTER:
         case DIE_INIT_MONARCH_ENTER:
                 xpc_vars->heartbeat++;
                 xpc_vars->heartbeat_offline = 1;
                 break;
+
+        case DIE_KDEBUG_LEAVE:
+                /* Is lack of heartbeat being ignored by other partitions? */
+                if (!xpc_kdebug_ignore) {
+                        break;
+                }
+                /* fall through */
         case DIE_MCA_MONARCH_LEAVE:
         case DIE_INIT_MONARCH_LEAVE:
                 xpc_vars->heartbeat++;
@@ -1344,3 +1409,7 @@ module_param(xpc_disengage_request_timelimit, int, 0);
 MODULE_PARM_DESC(xpc_disengage_request_timelimit, "Number of seconds to wait "
                 "for disengage request to complete.");
 
+module_param(xpc_kdebug_ignore, int, 0);
+MODULE_PARM_DESC(xpc_kdebug_ignore, "Should lack of heartbeat be ignored by "
+                "other partitions when dropping into kdebug.");
+
diff --git a/arch/ia64/sn/kernel/xpc_partition.c b/arch/ia64/sn/kernel/xpc_partition.c
index cdd6431853a1..88a730e6cfdb 100644
--- a/arch/ia64/sn/kernel/xpc_partition.c
+++ b/arch/ia64/sn/kernel/xpc_partition.c
@@ -3,7 +3,7 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (c) 2004-2005 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2004-2006 Silicon Graphics, Inc.  All Rights Reserved.
  */
 
 
@@ -28,7 +28,7 @@
 #include <asm/sn/sn_sal.h>
 #include <asm/sn/nodepda.h>
 #include <asm/sn/addrs.h>
-#include "xpc.h"
+#include <asm/sn/xpc.h>
 
 
 /* XPC is exiting flag */
@@ -771,7 +771,8 @@ xpc_identify_act_IRQ_req(int nasid)
                 }
         }
 
-        if (!xpc_partition_disengaged(part)) {
+        if (part->disengage_request_timeout > 0 &&
+                                        !xpc_partition_disengaged(part)) {
                 /* still waiting on other side to disengage from us */
                 return;
         }
@@ -873,6 +874,9 @@ xpc_partition_disengaged(struct xpc_partition *part)
                          * request in a timely fashion, so assume it's dead.
                          */
 
+                        dev_info(xpc_part, "disengage from remote partition %d "
+                                "timed out\n", partid);
+                        xpc_disengage_request_timedout = 1;
                         xpc_clear_partition_engaged(1UL << partid);
                         disengaged = 1;
                 }
diff --git a/arch/ia64/sn/pci/pcibr/pcibr_dma.c b/arch/ia64/sn/pci/pcibr/pcibr_dma.c
index 34093476e965..e68332d93171 100644
--- a/arch/ia64/sn/pci/pcibr/pcibr_dma.c
+++ b/arch/ia64/sn/pci/pcibr/pcibr_dma.c
@@ -218,7 +218,9 @@ void sn_dma_flush(uint64_t addr)
         uint64_t flags;
         uint64_t itte;
         struct hubdev_info *hubinfo;
-        volatile struct sn_flush_device_list *p;
+        volatile struct sn_flush_device_kernel *p;
+        volatile struct sn_flush_device_common *common;
+
         struct sn_flush_nasid_entry *flush_nasid_list;
 
         if (!sn_ioif_inited)
@@ -268,17 +270,17 @@ void sn_dma_flush(uint64_t addr)
         p = &flush_nasid_list->widget_p[wid_num][0];
 
         /* find a matching BAR */
-        for (i = 0; i < DEV_PER_WIDGET; i++) {
+        for (i = 0; i < DEV_PER_WIDGET; i++,p++) {
+                common = p->common;
                 for (j = 0; j < PCI_ROM_RESOURCE; j++) {
-                        if (p->sfdl_bar_list[j].start == 0)
+                        if (common->sfdl_bar_list[j].start == 0)
                                 break;
-                        if (addr >= p->sfdl_bar_list[j].start
-                            && addr <= p->sfdl_bar_list[j].end)
+                        if (addr >= common->sfdl_bar_list[j].start
+                            && addr <= common->sfdl_bar_list[j].end)
                                 break;
                 }
-                if (j < PCI_ROM_RESOURCE && p->sfdl_bar_list[j].start != 0)
+                if (j < PCI_ROM_RESOURCE && common->sfdl_bar_list[j].start != 0)
                         break;
-                p++;
         }
 
         /* if no matching BAR, return without doing anything. */
@@ -304,24 +306,24 @@ void sn_dma_flush(uint64_t addr)
                 if ((1 << XWIDGET_PART_REV_NUM_REV(revnum)) & PV907516) {
                         return;
                 } else {
-                        pcireg_wrb_flush_get(p->sfdl_pcibus_info,
-                                             (p->sfdl_slot - 1));
+                        pcireg_wrb_flush_get(common->sfdl_pcibus_info,
+                                             (common->sfdl_slot - 1));
                 }
         } else {
-                spin_lock_irqsave(&((struct sn_flush_device_list *)p)->
-                                  sfdl_flush_lock, flags);
-
-                *p->sfdl_flush_addr = 0;
+                spin_lock_irqsave((spinlock_t *)&p->sfdl_flush_lock,
+                                  flags);
+                *common->sfdl_flush_addr = 0;
 
                 /* force an interrupt. */
-                *(volatile uint32_t *)(p->sfdl_force_int_addr) = 1;
+                *(volatile uint32_t *)(common->sfdl_force_int_addr) = 1;
 
                 /* wait for the interrupt to come back. */
-                while (*(p->sfdl_flush_addr) != 0x10f)
+                while (*(common->sfdl_flush_addr) != 0x10f)
                         cpu_relax();
 
                 /* okay, everything is synched up. */
-                spin_unlock_irqrestore((spinlock_t *)&p->sfdl_flush_lock, flags);
+                spin_unlock_irqrestore((spinlock_t *)&p->sfdl_flush_lock,
+                                       flags);
         }
         return;
 }
diff --git a/arch/ia64/sn/pci/pcibr/pcibr_provider.c b/arch/ia64/sn/pci/pcibr/pcibr_provider.c
index 1f500c81002c..e328e948175d 100644
--- a/arch/ia64/sn/pci/pcibr/pcibr_provider.c
+++ b/arch/ia64/sn/pci/pcibr/pcibr_provider.c
@@ -92,7 +92,8 @@ pcibr_bus_fixup(struct pcibus_bussoft *prom_bussoft, struct pci_controller *cont
         cnodeid_t near_cnode;
         struct hubdev_info *hubdev_info;
         struct pcibus_info *soft;
-        struct sn_flush_device_list *sn_flush_device_list;
+        struct sn_flush_device_kernel *sn_flush_device_kernel;
+        struct sn_flush_device_common *common;
 
         if (! IS_PCI_BRIDGE_ASIC(prom_bussoft->bs_asic_type)) {
                 return NULL;
@@ -137,20 +138,19 @@ pcibr_bus_fixup(struct pcibus_bussoft *prom_bussoft, struct pci_controller *cont
         hubdev_info = (struct hubdev_info *)(NODEPDA(cnode)->pdinfo);
 
         if (hubdev_info->hdi_flush_nasid_list.widget_p) {
-                sn_flush_device_list = hubdev_info->hdi_flush_nasid_list.
+                sn_flush_device_kernel = hubdev_info->hdi_flush_nasid_list.
                     widget_p[(int)soft->pbi_buscommon.bs_xid];
-                if (sn_flush_device_list) {
+                if (sn_flush_device_kernel) {
                         for (j = 0; j < DEV_PER_WIDGET;
-                             j++, sn_flush_device_list++) {
-                                if (sn_flush_device_list->sfdl_slot == -1)
+                             j++, sn_flush_device_kernel++) {
+                                common = sn_flush_device_kernel->common;
+                                if (common->sfdl_slot == -1)
                                         continue;
-                                if ((sn_flush_device_list->
-                                     sfdl_persistent_segment ==
+                                if ((common->sfdl_persistent_segment ==
                                      soft->pbi_buscommon.bs_persist_segment) &&
-                                     (sn_flush_device_list->
-                                     sfdl_persistent_busnum ==
+                                     (common->sfdl_persistent_busnum ==
                                      soft->pbi_buscommon.bs_persist_busnum))
-                                        sn_flush_device_list->sfdl_pcibus_info =
+                                        common->sfdl_pcibus_info =
                                             soft;
                         }
                 }
diff --git a/arch/parisc/kernel/drivers.c b/arch/parisc/kernel/drivers.c
index 1eaa0d37f677..2d804e2d16d1 100644
--- a/arch/parisc/kernel/drivers.c
+++ b/arch/parisc/kernel/drivers.c
@@ -173,8 +173,6 @@ int register_parisc_driver(struct parisc_driver *driver)
         WARN_ON(driver->drv.probe != NULL);
         WARN_ON(driver->drv.remove != NULL);
 
-        driver->drv.probe = parisc_driver_probe;
-        driver->drv.remove = parisc_driver_remove;
         driver->drv.name = driver->name;
 
         return driver_register(&driver->drv);
@@ -575,6 +573,8 @@ struct bus_type parisc_bus_type = {
         .name = "parisc",
         .match = parisc_generic_match,
         .dev_attrs = parisc_device_attrs,
+        .probe = parisc_driver_probe,
+        .remove = parisc_driver_remove,
 };
 
 /**
diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig
index 01feed0e2a15..df338c5cc910 100644
--- a/arch/powerpc/Kconfig
+++ b/arch/powerpc/Kconfig
@@ -78,17 +78,6 @@ config PPC_UDBG_16550
         bool
         default n
 
-config CRASH_DUMP
-        bool "kernel crash dumps (EXPERIMENTAL)"
-        depends on PPC_MULTIPLATFORM
-        depends on EXPERIMENTAL
-        help
-          Build a kernel suitable for use as a kdump capture kernel.
-          The kernel will be linked at a different address than normal, and
-          so can only be used for Kdump.
-
-          Don't change this unless you know what you are doing.
-
 config GENERIC_TBSYNC
         bool
         default y if PPC32 && SMP
@@ -584,6 +573,16 @@ config KEXEC
           support.  As of this writing the exact hardware interface is
           strongly in flux, so no good recommendation can be made.
 
+config CRASH_DUMP
+        bool "kernel crash dumps (EXPERIMENTAL)"
+        depends on PPC_MULTIPLATFORM && PPC64 && EXPERIMENTAL
+        help
+          Build a kernel suitable for use as a kdump capture kernel.
+          The kernel will be linked at a different address than normal, and
+          so can only be used for Kdump.
+
+          Don't change this unless you know what you are doing.
+
 config EMBEDDEDBOOT
         bool
         depends on 8xx || 8260
diff --git a/arch/powerpc/Makefile b/arch/powerpc/Makefile
index d3654a264ef7..44dd82b791d1 100644
--- a/arch/powerpc/Makefile
+++ b/arch/powerpc/Makefile
@@ -139,17 +139,14 @@ drivers-$(CONFIG_CPM2)		+= arch/ppc/8260_io/
 
 drivers-$(CONFIG_OPROFILE)      += arch/powerpc/oprofile/
 
-defaultimage-$(CONFIG_PPC32)    := zImage
+# Default to zImage, override when needed
+defaultimage-y                  := zImage
 defaultimage-$(CONFIG_PPC_ISERIES) := vmlinux
-defaultimage-$(CONFIG_PPC_PSERIES) := zImage
 KBUILD_IMAGE := $(defaultimage-y)
 all: $(KBUILD_IMAGE)
 
 CPPFLAGS_vmlinux.lds    := -Upowerpc
 
-# All the instructions talk about "make bzImage".
-bzImage: zImage
-
 BOOT_TARGETS = zImage zImage.initrd znetboot znetboot.initrd vmlinux.sm uImage
 
 .PHONY: $(BOOT_TARGETS)
diff --git a/arch/powerpc/boot/Makefile b/arch/powerpc/boot/Makefile
index b53d677f6742..840ae595a617 100644
--- a/arch/powerpc/boot/Makefile
+++ b/arch/powerpc/boot/Makefile
@@ -25,8 +25,9 @@ HOSTCC		:= gcc
 BOOTCFLAGS      := $(HOSTCFLAGS) -fno-builtin -nostdinc -isystem \
                    $(shell $(CROSS32CC) -print-file-name=include) -fPIC
 BOOTAFLAGS      := -D__ASSEMBLY__ $(BOOTCFLAGS) -traditional -nostdinc
-BOOTLFLAGS      := -T $(srctree)/$(src)/zImage.lds
 OBJCOPYFLAGS    := contents,alloc,load,readonly,data
+OBJCOPY_COFF_ARGS := -O aixcoff-rs6000 --set-start 0x500000
+OBJCOPY_MIB_ARGS  := -O aixcoff-rs6000 -R .stab -R .stabstr -R .comment
 
 zlib       := infblock.c infcodes.c inffast.c inflate.c inftrees.c infutil.c
 zlibheader := infblock.h infcodes.h inffast.h inftrees.h infutil.h
@@ -35,7 +36,7 @@ zliblinuxheader := zlib.h zconf.h zutil.h
 $(addprefix $(obj)/,$(zlib) main.o): $(addprefix $(obj)/,$(zliblinuxheader)) $(addprefix $(obj)/,$(zlibheader))
 #$(addprefix $(obj)/,main.o): $(addprefix $(obj)/,zlib.h)
 
-src-boot := string.S prom.c main.c div64.S crt0.S
+src-boot := crt0.S string.S prom.c stdio.c main.c div64.S
 src-boot += $(zlib)
 src-boot := $(addprefix $(obj)/, $(src-boot))
 obj-boot := $(addsuffix .o, $(basename $(src-boot)))
@@ -70,7 +71,7 @@ quiet_cmd_bootas = BOOTAS  $@
       cmd_bootas = $(CROSS32CC) -Wp,-MD,$(depfile) $(BOOTAFLAGS) -c -o $@ $<
 
 quiet_cmd_bootld = BOOTLD  $@
-      cmd_bootld = $(CROSS32LD) $(BOOTLFLAGS) -o $@ $(2)
+      cmd_bootld = $(CROSS32LD) -T $(srctree)/$(src)/$(3) -o $@ $(2)
 
 $(patsubst %.c,%.o, $(filter %.c, $(src-boot))): %.o: %.c
         $(call if_changed_dep,bootcc)
@@ -87,12 +88,14 @@ 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             := addnote addRamDisk
-targets                 += zImage.vmode zImage.initrd.vmode zImage zImage.initrd \
-                           $(patsubst $(obj)/%,%, $(call obj-sec, $(required) $(initrd))) \
-                           $(patsubst $(obj)/%,%, $(call src-sec, $(required) $(initrd))) \
-                           $(patsubst $(obj)/%,%, $(call gz-sec, $(required) $(initrd))) \
-                           vmlinux.initrd
+hostprogs-y             := addnote addRamDisk hack-coff
+
+targets += zImage.vmode zImage.initrd.vmode zImage zImage.initrd \
+           zImage.coff zImage.initrd.coff miboot.image miboot.initrd.image \
+           $(patsubst $(obj)/%,%, $(call obj-sec, $(required) $(initrd))) \
+           $(patsubst $(obj)/%,%, $(call src-sec, $(required) $(initrd))) \
+           $(patsubst $(obj)/%,%, $(call gz-sec, $(required) $(initrd))) \
+           vmlinux.initrd dummy.o
 extra-y                 := initrd.o
 
 quiet_cmd_ramdisk = RAMDISK $@
@@ -114,6 +117,14 @@ quiet_cmd_addsection = ADDSEC  $@
 quiet_cmd_addnote = ADDNOTE $@
       cmd_addnote = $(obj)/addnote $@
 
+quiet_cmd_gen-miboot = GEN     $@
+      cmd_gen-miboot = $(OBJCOPY) $(OBJCOPY_MIB_ARGS) \
+                       --add-section=$1=$(word 2, $^) $< $@
+
+quiet_cmd_gencoff = COFF    $@
+      cmd_gencoff = $(OBJCOPY) $(OBJCOPY_COFF_ARGS) $@ && \
+                    $(obj)/hack-coff $@
+
 $(call gz-sec, $(required)): $(obj)/kernel-%.gz: %
         $(call if_changed,gzip)
 
@@ -127,22 +138,47 @@ $(call obj-sec, $(required) $(initrd)): $(obj)/kernel-%.o: $(obj)/kernel-%.c
         $(call if_changed_dep,bootcc)
         $(call cmd,addsection)
 
-$(obj)/zImage.vmode: obj-boot += $(call obj-sec, $(required))
+$(obj)/zImage.vmode $(obj)/zImage.coff: obj-boot += $(call obj-sec, $(required))
 $(obj)/zImage.vmode: $(call obj-sec, $(required)) $(obj-boot) $(srctree)/$(src)/zImage.lds
-        $(call cmd,bootld,$(obj-boot))
+        $(call cmd,bootld,$(obj-boot),zImage.lds)
 
-$(obj)/zImage.initrd.vmode: obj-boot += $(call obj-sec, $(required) $(initrd))
+$(obj)/zImage.initrd.vmode $(obj)/zImage.initrd.coff: obj-boot += $(call obj-sec, $(required) $(initrd))
 $(obj)/zImage.initrd.vmode: $(call obj-sec, $(required) $(initrd)) $(obj-boot) $(srctree)/$(src)/zImage.lds
-        $(call cmd,bootld,$(obj-boot))
+        $(call cmd,bootld,$(obj-boot),zImage.lds)
+
+# For 32-bit powermacs, build the COFF and miboot images
+# as well as the ELF images.
+coffimage-$(CONFIG_PPC_PMAC)-$(CONFIG_PPC32) := $(obj)/zImage.coff
+coffrdimg-$(CONFIG_PPC_PMAC)-$(CONFIG_PPC32) := $(obj)/zImage.initrd.coff
+mibootimg-$(CONFIG_PPC_PMAC)-$(CONFIG_PPC32) := $(obj)/miboot.image
+mibrdimg-$(CONFIG_PPC_PMAC)-$(CONFIG_PPC32)  := $(obj)/miboot.initrd.image
 
-$(obj)/zImage: $(obj)/zImage.vmode $(obj)/addnote
+$(obj)/zImage: $(obj)/zImage.vmode $(obj)/addnote $(coffimage-y-y) \
+                        $(mibootimg-y-y)
         @cp -f $< $@
         $(call if_changed,addnote)
 
-$(obj)/zImage.initrd: $(obj)/zImage.initrd.vmode $(obj)/addnote
+$(obj)/zImage.initrd: $(obj)/zImage.initrd.vmode $(obj)/addnote \
+                        $(coffrdimg-y-y) $(mibrdimg-y-y)
         @cp -f $< $@
         $(call if_changed,addnote)
 
+$(obj)/zImage.coff: $(call obj-sec, $(required)) $(obj-boot) \
+                        $(srctree)/$(src)/zImage.coff.lds $(obj)/hack-coff
+        $(call cmd,bootld,$(obj-boot),zImage.coff.lds)
+        $(call cmd,gencoff)
+
+$(obj)/zImage.initrd.coff: $(call obj-sec, $(required) $(initrd)) $(obj-boot) \
+                           $(srctree)/$(src)/zImage.coff.lds $(obj)/hack-coff
+        $(call cmd,bootld,$(obj-boot),zImage.coff.lds)
+        $(call cmd,gencoff)
+
+$(obj)/miboot.image: $(obj)/dummy.o $(obj)/vmlinux.gz
+        $(call cmd,gen-miboot,image)
+
+$(obj)/miboot.initrd.image: $(obj)/miboot.image $(images)/ramdisk.image.gz
+        $(call cmd,gen-miboot,initrd)
+
 #-----------------------------------------------------------
 # build u-boot images
 #-----------------------------------------------------------
diff --git a/arch/powerpc/boot/crt0.S b/arch/powerpc/boot/crt0.S
index d2f2ace56cd3..e0192c26037b 100644
--- a/arch/powerpc/boot/crt0.S
+++ b/arch/powerpc/boot/crt0.S
@@ -12,17 +12,23 @@
 #include "ppc_asm.h"
 
         .text
+        /* a procedure descriptor used when booting this as a COFF file */
+_zimage_start_opd:
+        .long   _zimage_start, 0, 0, 0
+
         .globl  _zimage_start
 _zimage_start:
+        /* Work out the offset between the address we were linked at
+           and the address where we're running. */
         bl      1f
-
-1:
-        mflr    r0
+1:      mflr    r0
         lis     r9,1b@ha
         addi    r9,r9,1b@l
         subf.   r0,r9,r0
-        beq     3f
+        beq     3f              /* if running at same address as linked */
 
+        /* The .got2 section contains a list of addresses, so add
+           the address offset onto each entry. */
         lis     r9,__got2_start@ha
         addi    r9,r9,__got2_start@l
         lis     r8,__got2_end@ha
@@ -32,15 +38,14 @@ _zimage_start:
         srwi.   r8,r8,2
         mtctr   r8
         add     r9,r0,r9
-2:
-        lwz     r8,0(r9)
+2:      lwz     r8,0(r9)
         add     r8,r8,r0
         stw     r8,0(r9)
         addi    r9,r9,4
         bdnz    2b
 
-3:
-        lis     r9,_start@h
+        /* Do a cache flush for our text, in case OF didn't */
+3:      lis     r9,_start@h
         add     r9,r0,r9
         lis     r8,_etext@ha
         addi    r8,r8,_etext@l
diff --git a/arch/powerpc/boot/dummy.c b/arch/powerpc/boot/dummy.c
new file mode 100644
index 000000000000..31dbf45bf99c
--- /dev/null
+++ b/arch/powerpc/boot/dummy.c
@@ -0,0 +1,4 @@
+int main(void)
+{
+        return 0;
+}
diff --git a/arch/powerpc/boot/hack-coff.c b/arch/powerpc/boot/hack-coff.c
new file mode 100644
index 000000000000..5e5a6573a1ef
--- /dev/null
+++ b/arch/powerpc/boot/hack-coff.c
@@ -0,0 +1,84 @@
+/*
+ * hack-coff.c - hack the header of an xcoff file to fill in
+ * a few fields needed by the Open Firmware xcoff loader on
+ * Power Macs but not initialized by objcopy.
+ *
+ * Copyright (C) Paul Mackerras 1997.
+ *
+ * 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 <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include "rs6000.h"
+
+#define AOUT_MAGIC      0x010b
+
+#define get_16be(x)     ((((unsigned char *)(x))[0] << 8) \
+                         + ((unsigned char *)(x))[1])
+#define put_16be(x, v)  (((unsigned char *)(x))[0] = (v) >> 8, \
+                         ((unsigned char *)(x))[1] = (v) & 0xff)
+#define get_32be(x)     ((((unsigned char *)(x))[0] << 24) \
+                         + (((unsigned char *)(x))[1] << 16) \
+                         + (((unsigned char *)(x))[2] << 8) \
+                         + ((unsigned char *)(x))[3])
+
+int
+main(int ac, char **av)
+{
+    int fd;
+    int i, nsect;
+    int aoutsz;
+    struct external_filehdr fhdr;
+    AOUTHDR aout;
+    struct external_scnhdr shdr;
+
+    if (ac != 2) {
+        fprintf(stderr, "Usage: hack-coff coff-file\n");
+        exit(1);
+    }
+    if ((fd = open(av[1], 2)) == -1) {
+        perror(av[2]);
+        exit(1);
+    }
+    if (read(fd, &fhdr, sizeof(fhdr)) != sizeof(fhdr))
+        goto readerr;
+    i = get_16be(fhdr.f_magic);
+    if (i != U802TOCMAGIC && i != U802WRMAGIC && i != U802ROMAGIC) {
+        fprintf(stderr, "%s: not an xcoff file\n", av[1]);
+        exit(1);
+    }
+    aoutsz = get_16be(fhdr.f_opthdr);
+    if (read(fd, &aout, aoutsz) != aoutsz)
+        goto readerr;
+    nsect = get_16be(fhdr.f_nscns);
+    for (i = 0; i < nsect; ++i) {
+        if (read(fd, &shdr, sizeof(shdr)) != sizeof(shdr))
+            goto readerr;
+        if (strcmp(shdr.s_name, ".text") == 0) {
+            put_16be(aout.o_snentry, i+1);
+            put_16be(aout.o_sntext, i+1);
+        } else if (strcmp(shdr.s_name, ".data") == 0) {
+            put_16be(aout.o_sndata, i+1);
+        } else if (strcmp(shdr.s_name, ".bss") == 0) {
+            put_16be(aout.o_snbss, i+1);
+        }
+    }
+    put_16be(aout.magic, AOUT_MAGIC);
+    if (lseek(fd, (long) sizeof(struct external_filehdr), 0) == -1
+        || write(fd, &aout, aoutsz) != aoutsz) {
+        fprintf(stderr, "%s: write error\n", av[1]);
+        exit(1);
+    }
+    close(fd);
+    exit(0);
+
+readerr:
+    fprintf(stderr, "%s: read error or file too short\n", av[1]);
+    exit(1);
+}
diff --git a/arch/powerpc/boot/main.c b/arch/powerpc/boot/main.c
index 64ec93116fa6..55ec59867250 100644
--- a/arch/powerpc/boot/main.c
+++ b/arch/powerpc/boot/main.c
@@ -21,8 +21,8 @@ extern void flush_cache(void *, unsigned long);
 
 
 /* Value picked to match that used by yaboot */
-#define PROG_START      0x01400000
-#define RAM_END         (512<<20) // Fixme: use OF */
+#define PROG_START      0x01400000      /* only used on 64-bit systems */
+#define RAM_END         (512<<20)       /* Fixme: use OF */
 #define ONE_MB          0x100000
 
 extern char _start[];
@@ -160,6 +160,17 @@ static int is_elf64(void *hdr)
         elfoffset = (unsigned long)elf64ph->p_offset;
         vmlinux.size = (unsigned long)elf64ph->p_filesz + elfoffset;
         vmlinux.memsize = (unsigned long)elf64ph->p_memsz + elfoffset;
+
+#if defined(PROG_START)
+        /*
+         * Maintain a "magic" minimum address. This keeps some older
+         * firmware platforms running.
+         */
+
+        if (claim_base < PROG_START)
+                claim_base = PROG_START;
+#endif
+
         return 1;
 }
 
@@ -206,12 +217,18 @@ void start(unsigned long a1, unsigned long a2, void *promptr, void *sp)
                 exit();
         if (getprop(chosen_handle, "stdout", &stdout, sizeof(stdout)) != 4)
                 exit();
-        stderr = stdout;
-        if (getprop(chosen_handle, "stdin", &stdin, sizeof(stdin)) != 4)
-                exit();
 
         printf("\n\rzImage starting: loaded at 0x%p (sp: 0x%p)\n\r", _start, sp);
 
+        /*
+         * The first available claim_base must be above the end of the
+         * the loaded kernel wrapper file (_start to _end includes the
+         * initrd image if it is present) and rounded up to a nice
+         * 1 MB boundary for good measure.
+         */
+
+        claim_base = _ALIGN_UP((unsigned long)_end, ONE_MB);
+
         vmlinuz.addr = (unsigned long)_vmlinux_start;
         vmlinuz.size = (unsigned long)(_vmlinux_end - _vmlinux_start);
 
@@ -228,25 +245,6 @@ void start(unsigned long a1, unsigned long a2, void *promptr, void *sp)
                 exit();
         }
 
-        /*
-         * The first available claim_base must be above the end of the
-         * the loaded kernel wrapper file (_start to _end includes the
-         * initrd image if it is present) and rounded up to a nice
-         * 1 MB boundary for good measure.
-         */
-
-        claim_base = _ALIGN_UP((unsigned long)_end, ONE_MB);
-
-#if defined(PROG_START)
-        /*
-         * Maintain a "magic" minimum address. This keeps some older
-         * firmware platforms running.
-         */
-
-        if (claim_base < PROG_START)
-                claim_base = PROG_START;
-#endif
-
         /* We need to claim the memsize plus the file offset since gzip
          * will expand the header (file offset), then the kernel, then
          * possible rubbish we don't care about. But the kernel bss must
diff --git a/arch/powerpc/boot/prom.c b/arch/powerpc/boot/prom.c
index 4bea2f4dcb06..fa0057736f6b 100644
--- a/arch/powerpc/boot/prom.c
+++ b/arch/powerpc/boot/prom.c
@@ -13,487 +13,153 @@
 #include "prom.h"
 
 int (*prom)(void *);
+phandle chosen_handle;
+ihandle stdout;
 
-void *chosen_handle;
-
-void *stdin;
-void *stdout;
-void *stderr;
-
-
-int
-write(void *handle, void *ptr, int nb)
-{
-        struct prom_args {
-                char *service;
-                int nargs;
-                int nret;
-                void *ihandle;
-                void *addr;
-                int len;
-                int actual;
-        } args;
-
-        args.service = "write";
-        args.nargs = 3;
-        args.nret = 1;
-        args.ihandle = handle;
-        args.addr = ptr;
-        args.len = nb;
-        args.actual = -1;
-        (*prom)(&args);
-        return args.actual;
-}
-
-int
-read(void *handle, void *ptr, int nb)
+int call_prom(const char *service, int nargs, int nret, ...)
 {
+        int i;
         struct prom_args {
-                char *service;
+                const char *service;
                 int nargs;
                 int nret;
-                void *ihandle;
-                void *addr;
-                int len;
-                int actual;
-        } args;
-
-        args.service = "read";
-        args.nargs = 3;
-        args.nret = 1;
-        args.ihandle = handle;
-        args.addr = ptr;
-        args.len = nb;
-        args.actual = -1;
-        (*prom)(&args);
-        return args.actual;
-}
-
-void
-exit()
-{
-        struct prom_args {
-                char *service;
-        } args;
-
-        for (;;) {
-                args.service = "exit";
-                (*prom)(&args);
-        }
-}
-
-void
-pause(void)
-{
-        struct prom_args {
-                char *service;
+                unsigned int args[12];
         } args;
+        va_list list;
 
-        args.service = "enter";
-        (*prom)(&args);
-}
+        args.service = service;
+        args.nargs = nargs;
+        args.nret = nret;
 
-void *
-finddevice(const char *name)
-{
-        struct prom_args {
-                char *service;
-                int nargs;
-                int nret;
-                const char *devspec;
-                void *phandle;
-        } args;
+        va_start(list, nret);
+        for (i = 0; i < nargs; i++)
+                args.args[i] = va_arg(list, unsigned int);
+        va_end(list);
 
-        args.service = "finddevice";
-        args.nargs = 1;
-        args.nret = 1;
-        args.devspec = name;
-        args.phandle = (void *) -1;
-        (*prom)(&args);
-        return args.phandle;
-}
+        for (i = 0; i < nret; i++)
+                args.args[nargs+i] = 0;
 
-void *
-claim(unsigned long virt, unsigned long size, unsigned long align)
-{
-        struct prom_args {
-                char *service;
-                int nargs;
-                int nret;
-                unsigned int virt;
-                unsigned int size;
-                unsigned int align;
-                void *ret;
-        } args;
+        if (prom(&args) < 0)
+                return -1;
 
-        args.service = "claim";
-        args.nargs = 3;
-        args.nret = 1;
-        args.virt = virt;
-        args.size = size;
-        args.align = align;
-        (*prom)(&args);
-        return args.ret;
+        return (nret > 0)? args.args[nargs]: 0;
 }
 
-int
-getprop(void *phandle, const char *name, void *buf, int buflen)
+int call_prom_ret(const char *service, int nargs, int nret,
+                  unsigned int *rets, ...)
 {
+        int i;
         struct prom_args {
-                char *service;
+                const char *service;
                 int nargs;
                 int nret;
-                void *phandle;
-                const char *name;
-                void *buf;
-                int buflen;
-                int size;
+                unsigned int args[12];
         } args;
+        va_list list;
 
-        args.service = "getprop";
-        args.nargs = 4;
-        args.nret = 1;
-        args.phandle = phandle;
-        args.name = name;
-        args.buf = buf;
-        args.buflen = buflen;
-        args.size = -1;
-        (*prom)(&args);
-        return args.size;
-}
+        args.service = service;
+        args.nargs = nargs;
+        args.nret = nret;
 
-int
-putc(int c, void *f)
-{
-        char ch = c;
+        va_start(list, rets);
+        for (i = 0; i < nargs; i++)
+                args.args[i] = va_arg(list, unsigned int);
+        va_end(list);
 
-        if (c == '\n')
-                putc('\r', f);
-        return write(f, &ch, 1) == 1? c: -1;
-}
+        for (i = 0; i < nret; i++)
+                args.args[nargs+i] = 0;
 
-int
-putchar(int c)
-{
-        return putc(c, stdout);
-}
+        if (prom(&args) < 0)
+                return -1;
 
-int
-fputs(char *str, void *f)
-{
-        int n = strlen(str);
+        if (rets != (void *) 0)
+                for (i = 1; i < nret; ++i)
+                        rets[i-1] = args.args[nargs+i];
 
-        return write(f, str, n) == n? 0: -1;
+        return (nret > 0)? args.args[nargs]: 0;
 }
 
-size_t strnlen(const char * s, size_t count)
+int write(void *handle, void *ptr, int nb)
 {
-        const char *sc;
-
-        for (sc = s; count-- && *sc != '\0'; ++sc)
-                /* nothing */;
-        return sc - s;
+        return call_prom("write", 3, 1, handle, ptr, nb);
 }
 
-extern unsigned int __div64_32(unsigned long long *dividend,
-                               unsigned int divisor);
-
-/* The unnecessary pointer compare is there
- * to check for type safety (n must be 64bit)
+/*
+ * Older OF's require that when claiming a specific range of addresses,
+ * we claim the physical space in the /memory node and the virtual
+ * space in the chosen mmu node, and then do a map operation to
+ * map virtual to physical.
  */
-# define do_div(n,base) ({                                              \
-        unsigned int __base = (base);                                   \
-        unsigned int __rem;                                             \
-        (void)(((typeof((n)) *)0) == ((unsigned long long *)0));        \
-        if (((n) >> 32) == 0) {                                         \
-                __rem = (unsigned int)(n) % __base;                     \
-                (n) = (unsigned int)(n) / __base;                       \
-        } else                                                          \
-                __rem = __div64_32(&(n), __base);                       \
-        __rem;                                                          \
- })
+static int need_map = -1;
+static ihandle chosen_mmu;
+static phandle memory;
 
-static int skip_atoi(const char **s)
+/* returns true if s2 is a prefix of s1 */
+static int string_match(const char *s1, const char *s2)
 {
-        int i, c;
-
-        for (i = 0; '0' <= (c = **s) && c <= '9'; ++*s)
-                i = i*10 + c - '0';
-        return i;
+        for (; *s2; ++s2)
+                if (*s1++ != *s2)
+                        return 0;
+        return 1;
 }
 
-#define ZEROPAD 1               /* pad with zero */
-#define SIGN    2               /* unsigned/signed long */
-#define PLUS    4               /* show plus */
-#define SPACE   8               /* space if plus */
-#define LEFT    16              /* left justified */
-#define SPECIAL 32              /* 0x */
-#define LARGE   64              /* use 'ABCDEF' instead of 'abcdef' */
-
-static char * number(char * str, unsigned long long num, int base, int size, int precision, int type)
+static int check_of_version(void)
 {
-        char c,sign,tmp[66];
-        const char *digits="0123456789abcdefghijklmnopqrstuvwxyz";
-        int i;
+        phandle oprom, chosen;
+        char version[64];
 
-        if (type & LARGE)
-                digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-        if (type & LEFT)
-                type &= ~ZEROPAD;
-        if (base < 2 || base > 36)
+        oprom = finddevice("/openprom");
+        if (oprom == (phandle) -1)
                 return 0;
-        c = (type & ZEROPAD) ? '0' : ' ';
-        sign = 0;
-        if (type & SIGN) {
-                if ((signed long long)num < 0) {
-                        sign = '-';
-                        num = - (signed long long)num;
-                        size--;
-                } else if (type & PLUS) {
-                        sign = '+';
-                        size--;
-                } else if (type & SPACE) {
-                        sign = ' ';
-                        size--;
+        if (getprop(oprom, "model", version, sizeof(version)) <= 0)
+                return 0;
+        version[sizeof(version)-1] = 0;
+        printf("OF version = '%s'\r\n", version);
+        if (!string_match(version, "Open Firmware, 1.")
+            && !string_match(version, "FirmWorks,3."))
+                return 0;
+        chosen = finddevice("/chosen");
+        if (chosen == (phandle) -1) {
+                chosen = finddevice("/chosen@0");
+                if (chosen == (phandle) -1) {
+                        printf("no chosen\n");
+                        return 0;
                 }
         }
-        if (type & SPECIAL) {
-                if (base == 16)
-                        size -= 2;
-                else if (base == 8)
-                        size--;
-        }
-        i = 0;
-        if (num == 0)
-                tmp[i++]='0';
-        else while (num != 0) {
-                tmp[i++] = digits[do_div(num, base)];
+        if (getprop(chosen, "mmu", &chosen_mmu, sizeof(chosen_mmu)) <= 0) {
+                printf("no mmu\n");
+                return 0;
         }
-        if (i > precision)
-                precision = i;
-        size -= precision;
-        if (!(type&(ZEROPAD+LEFT)))
-                while(size-->0)
-                        *str++ = ' ';
-        if (sign)
-                *str++ = sign;
-        if (type & SPECIAL) {
-                if (base==8)
-                        *str++ = '0';
-                else if (base==16) {
-                        *str++ = '0';
-                        *str++ = digits[33];
+        memory = (ihandle) call_prom("open", 1, 1, "/memory");
+        if (memory == (ihandle) -1) {
+                memory = (ihandle) call_prom("open", 1, 1, "/memory@0");
+                if (memory == (ihandle) -1) {
+                        printf("no memory node\n");
+                        return 0;
                 }
         }
-        if (!(type & LEFT))
-                while (size-- > 0)
-                        *str++ = c;
-        while (i < precision--)
-                *str++ = '0';
-        while (i-- > 0)
-                *str++ = tmp[i];
-        while (size-- > 0)
-                *str++ = ' ';
-        return str;
+        printf("old OF detected\r\n");
+        return 1;
 }
 
-int vsprintf(char *buf, const char *fmt, va_list args)
+void *claim(unsigned long virt, unsigned long size, unsigned long align)
 {
-        int len;
-        unsigned long long num;
-        int i, base;
-        char * str;
-        const char *s;
-
-        int flags;              /* flags to number() */
-
-        int field_width;        /* width of output field */
-        int precision;          /* min. # of digits for integers; max
-                                   number of chars for from string */
-        int qualifier;          /* 'h', 'l', or 'L' for integer fields */
-                                /* 'z' support added 23/7/1999 S.H.    */
-                                /* 'z' changed to 'Z' --davidm 1/25/99 */
+        int ret;
+        unsigned int result;
 
+        if (need_map < 0)
+                need_map = check_of_version();
+        if (align || !need_map)
+                return (void *) call_prom("claim", 3, 1, virt, size, align);
         
-        for (str=buf ; *fmt ; ++fmt) {
-                if (*fmt != '%') {
-                        *str++ = *fmt;
-                        continue;
-                }
-                        
-                /* process flags */
-                flags = 0;
-                repeat:
-                        ++fmt;          /* this also skips first '%' */
-                        switch (*fmt) {
-                                case '-': flags |= LEFT; goto repeat;
-                                case '+': flags |= PLUS; goto repeat;
-                                case ' ': flags |= SPACE; goto repeat;
-                                case '#': flags |= SPECIAL; goto repeat;
-                                case '0': flags |= ZEROPAD; goto repeat;
-                                }
-                
-                /* get field width */
-                field_width = -1;
-                if ('0' <= *fmt && *fmt <= '9')
-                        field_width = skip_atoi(&fmt);
-                else if (*fmt == '*') {
-                        ++fmt;
-                        /* it's the next argument */
-                        field_width = va_arg(args, int);
-                        if (field_width < 0) {
-                                field_width = -field_width;
-                                flags |= LEFT;
-                        }
-                }
-
-                /* get the precision */
-                precision = -1;
-                if (*fmt == '.') {
-                        ++fmt;  
-                        if ('0' <= *fmt && *fmt <= '9')
-                                precision = skip_atoi(&fmt);
-                        else if (*fmt == '*') {
-                                ++fmt;
-                                /* it's the next argument */
-                                precision = va_arg(args, int);
-                        }
-                        if (precision < 0)
-                                precision = 0;
-                }
-
-                /* get the conversion qualifier */
-                qualifier = -1;
-                if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || *fmt =='Z') {
-                        qualifier = *fmt;
-                        ++fmt;
-                }
-
-                /* default base */
-                base = 10;
-
-                switch (*fmt) {
-                case 'c':
-                        if (!(flags & LEFT))
-                                while (--field_width > 0)
-                                        *str++ = ' ';
-                        *str++ = (unsigned char) va_arg(args, int);
-                        while (--field_width > 0)
-                                *str++ = ' ';
-                        continue;
-
-                case 's':
-                        s = va_arg(args, char *);
-                        if (!s)
-                                s = "<NULL>";
-
-                        len = strnlen(s, precision);
-
-                        if (!(flags & LEFT))
-                                while (len < field_width--)
-                                        *str++ = ' ';
-                        for (i = 0; i < len; ++i)
-                                *str++ = *s++;
-                        while (len < field_width--)
-                                *str++ = ' ';
-                        continue;
-
-                case 'p':
-                        if (field_width == -1) {
-                                field_width = 2*sizeof(void *);
-                                flags |= ZEROPAD;
-                        }
-                        str = number(str,
-                                (unsigned long) va_arg(args, void *), 16,
-                                field_width, precision, flags);
-                        continue;
-
-
-                case 'n':
-                        if (qualifier == 'l') {
-                                long * ip = va_arg(args, long *);
-                                *ip = (str - buf);
-                        } else if (qualifier == 'Z') {
-                                size_t * ip = va_arg(args, size_t *);
-                                *ip = (str - buf);
-                        } else {
-                                int * ip = va_arg(args, int *);
-                                *ip = (str - buf);
-                        }
-                        continue;
-
-                case '%':
-                        *str++ = '%';
-                        continue;
-
-                /* integer number formats - set up the flags and "break" */
-                case 'o':
-                        base = 8;
-                        break;
-
-                case 'X':
-                        flags |= LARGE;
-                case 'x':
-                        base = 16;
-                        break;
-
-                case 'd':
-                case 'i':
-                        flags |= SIGN;
-                case 'u':
-                        break;
-
-                default:
-                        *str++ = '%';
-                        if (*fmt)
-                                *str++ = *fmt;
-                        else
-                                --fmt;
-                        continue;
-                }
-                if (qualifier == 'l') {
-                        num = va_arg(args, unsigned long);
-                        if (flags & SIGN)
-                                num = (signed long) num;
-                } else if (qualifier == 'Z') {
-                        num = va_arg(args, size_t);
-                } else if (qualifier == 'h') {
-                        num = (unsigned short) va_arg(args, int);
-                        if (flags & SIGN)
-                                num = (signed short) num;
-                } else {
-                        num = va_arg(args, unsigned int);
-                        if (flags & SIGN)
-                                num = (signed int) num;
-                }
-                str = number(str, num, base, field_width, precision, flags);
-        }
-        *str = '\0';
-        return str-buf;
-}
-
-int sprintf(char * buf, const char *fmt, ...)
-{
-        va_list args;
-        int i;
-
-        va_start(args, fmt);
-        i=vsprintf(buf,fmt,args);
-        va_end(args);
-        return i;
-}
-
-static char sprint_buf[1024];
-
-int
-printf(const 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);
-        return n;
+        ret = call_prom_ret("call-method", 5, 2, &result, "claim", memory,
+                            align, size, virt);
+        if (ret != 0 || result == -1)
+                return (void *) -1;
+        ret = call_prom_ret("call-method", 5, 2, &result, "claim", chosen_mmu,
+                            align, size, virt);
+        /* 0x12 == coherent + read/write */
+        ret = call_prom("call-method", 6, 1, "map", chosen_mmu,
+                        0x12, size, virt, virt);
+        return (void *) virt;
 }
diff --git a/arch/powerpc/boot/prom.h b/arch/powerpc/boot/prom.h
index 96ab5aec740c..3e2ddd4a5a81 100644
--- a/arch/powerpc/boot/prom.h
+++ b/arch/powerpc/boot/prom.h
@@ -1,18 +1,34 @@
 #ifndef _PPC_BOOT_PROM_H_
 #define _PPC_BOOT_PROM_H_
 
+typedef void *phandle;
+typedef void *ihandle;
+
 extern int (*prom) (void *);
-extern void *chosen_handle;
+extern phandle chosen_handle;
+extern ihandle stdout;
 
-extern void *stdin;
-extern void *stdout;
-extern void *stderr;
+int     call_prom(const char *service, int nargs, int nret, ...);
+int     call_prom_ret(const char *service, int nargs, int nret,
+                      unsigned int *rets, ...);
 
 extern int write(void *handle, void *ptr, int nb);
-extern int read(void *handle, void *ptr, int nb);
-extern void exit(void);
-extern void pause(void);
-extern void *finddevice(const char *);
-extern void *claim(unsigned long virt, unsigned long size, unsigned long align);
-extern int getprop(void *phandle, const char *name, void *buf, int buflen);
+extern void *claim(unsigned long virt, unsigned long size, unsigned long aln);
+
+static inline void exit(void)
+{
+        call_prom("exit", 0, 0);
+}
+
+static inline phandle finddevice(const char *name)
+{
+        return (phandle) call_prom("finddevice", 1, 1, name);
+}
+
+static inline int getprop(void *phandle, const char *name,
+                          void *buf, int buflen)
+{
+        return call_prom("getprop", 4, 1, phandle, name, buf, buflen);
+}
+
 #endif                          /* _PPC_BOOT_PROM_H_ */
diff --git a/arch/powerpc/boot/rs6000.h b/arch/powerpc/boot/rs6000.h
new file mode 100644
index 000000000000..433f45084e41
--- /dev/null
+++ b/arch/powerpc/boot/rs6000.h
@@ -0,0 +1,243 @@
+/* IBM RS/6000 "XCOFF" file definitions for BFD.
+   Copyright (C) 1990, 1991 Free Software Foundation, Inc.
+   FIXME: Can someone provide a transliteration of this name into ASCII?
+   Using the following chars caused a compiler warning on HIUX (so I replaced
+   them with octal escapes), and isn't useful without an understanding of what
+   character set it is.
+   Written by Mimi Ph\373\364ng-Th\345o V\365 of IBM
+   and John Gilmore of Cygnus Support.  */
+
+/********************** FILE HEADER **********************/
+
+struct external_filehdr {
+        char f_magic[2];        /* magic number                 */
+        char f_nscns[2];        /* number of sections           */
+        char f_timdat[4];       /* time & date stamp            */
+        char f_symptr[4];       /* file pointer to symtab       */
+        char f_nsyms[4];        /* number of symtab entries     */
+        char f_opthdr[2];       /* sizeof(optional hdr)         */
+        char f_flags[2];        /* flags                        */
+};
+
+        /* IBM RS/6000 */
+#define U802WRMAGIC     0730    /* writeable text segments **chh**      */
+#define U802ROMAGIC     0735    /* readonly sharable text segments      */
+#define U802TOCMAGIC    0737    /* readonly text segments and TOC       */
+
+#define BADMAG(x)       \
+        ((x).f_magic != U802ROMAGIC && (x).f_magic != U802WRMAGIC && \
+         (x).f_magic != U802TOCMAGIC)
+
+#define FILHDR  struct external_filehdr
+#define FILHSZ  20
+
+
+/********************** AOUT "OPTIONAL HEADER" **********************/
+
+
+typedef struct
+{
+  unsigned char magic[2];       /* type of file                 */
+  unsigned char vstamp[2];      /* version stamp                */
+  unsigned char tsize[4];       /* text size in bytes, padded to FW bdry */
+  unsigned char dsize[4];       /* initialized data "  "        */
+  unsigned char bsize[4];       /* uninitialized data "   "     */
+  unsigned char entry[4];       /* entry pt.                    */
+  unsigned char text_start[4];  /* base of text used for this file */
+  unsigned char data_start[4];  /* base of data used for this file */
+  unsigned char o_toc[4];       /* address of TOC */
+  unsigned char o_snentry[2];   /* section number of entry point */
+  unsigned char o_sntext[2];    /* section number of .text section */
+  unsigned char o_sndata[2];    /* section number of .data section */
+  unsigned char o_sntoc[2];     /* section number of TOC */
+  unsigned char o_snloader[2];  /* section number of .loader section */
+  unsigned char o_snbss[2];     /* section number of .bss section */
+  unsigned char o_algntext[2];  /* .text alignment */
+  unsigned char o_algndata[2];  /* .data alignment */
+  unsigned char o_modtype[2];   /* module type (??) */
+  unsigned char o_cputype[2];   /* cpu type */
+  unsigned char o_maxstack[4];  /* max stack size (??) */
+  unsigned char o_maxdata[4];   /* max data size (??) */
+  unsigned char o_resv2[12];    /* reserved */
+}
+AOUTHDR;
+
+#define AOUTSZ 72
+#define SMALL_AOUTSZ (28)
+#define AOUTHDRSZ 72
+
+#define RS6K_AOUTHDR_OMAGIC     0x0107  /* old: text & data writeable */
+#define RS6K_AOUTHDR_NMAGIC     0x0108  /* new: text r/o, data r/w */
+#define RS6K_AOUTHDR_ZMAGIC     0x010B  /* paged: text r/o, both page-aligned */
+
+
+/********************** SECTION HEADER **********************/
+
+
+struct external_scnhdr {
+        char            s_name[8];      /* section name                 */
+        char            s_paddr[4];     /* physical address, aliased s_nlib */
+        char            s_vaddr[4];     /* virtual address              */
+        char            s_size[4];      /* section size                 */
+        char            s_scnptr[4];    /* file ptr to raw data for section */
+        char            s_relptr[4];    /* file ptr to relocation       */
+        char            s_lnnoptr[4];   /* file ptr to line numbers     */
+        char            s_nreloc[2];    /* number of relocation entries */
+        char            s_nlnno[2];     /* number of line number entries*/
+        char            s_flags[4];     /* flags                        */
+};
+
+/*
+ * names of "special" sections
+ */
+#define _TEXT   ".text"
+#define _DATA   ".data"
+#define _BSS    ".bss"
+#define _PAD    ".pad"
+#define _LOADER ".loader"
+
+#define SCNHDR  struct external_scnhdr
+#define SCNHSZ  40
+
+/* XCOFF uses a special .loader section with type STYP_LOADER.  */
+#define STYP_LOADER 0x1000
+
+/* XCOFF uses a special .debug section with type STYP_DEBUG.  */
+#define STYP_DEBUG 0x2000
+
+/* XCOFF handles line number or relocation overflow by creating
+   another section header with STYP_OVRFLO set.  */
+#define STYP_OVRFLO 0x8000
+
+/********************** LINE NUMBERS **********************/
+
+/* 1 line number entry for every "breakpointable" source line in a section.
+ * Line numbers are grouped on a per function basis; first entry in a function
+ * grouping will have l_lnno = 0 and in place of physical address will be the
+ * symbol table index of the function name.
+ */
+struct external_lineno {
+        union {
+                char l_symndx[4];       /* function name symbol index, iff l_lnno == 0*/
+                char l_paddr[4];        /* (physical) address of line number    */
+        } l_addr;
+        char l_lnno[2]; /* line number          */
+};
+
+
+#define LINENO  struct external_lineno
+#define LINESZ  6
+
+
+/********************** SYMBOLS **********************/
+
+#define E_SYMNMLEN      8       /* # characters in a symbol name        */
+#define E_FILNMLEN      14      /* # characters in a file name          */
+#define E_DIMNUM        4       /* # array dimensions in auxiliary entry */
+
+struct external_syment
+{
+  union {
+    char e_name[E_SYMNMLEN];
+    struct {
+      char e_zeroes[4];
+      char e_offset[4];
+    } e;
+  } e;
+  char e_value[4];
+  char e_scnum[2];
+  char e_type[2];
+  char e_sclass[1];
+  char e_numaux[1];
+};
+
+
+
+#define N_BTMASK        (017)
+#define N_TMASK         (060)
+#define N_BTSHFT        (4)
+#define N_TSHIFT        (2)
+
+
+union external_auxent {
+        struct {
+                char x_tagndx[4];       /* str, un, or enum tag indx */
+                union {
+                        struct {
+                            char  x_lnno[2]; /* declaration line number */
+                            char  x_size[2]; /* str/union/array size */
+                        } x_lnsz;
+                        char x_fsize[4];        /* size of function */
+                } x_misc;
+                union {
+                        struct {                /* if ISFCN, tag, or .bb */
+                            char x_lnnoptr[4];  /* ptr to fcn line # */
+                            char x_endndx[4];   /* entry ndx past block end */
+                        } x_fcn;
+                        struct {                /* if ISARY, up to 4 dimen. */
+                            char x_dimen[E_DIMNUM][2];
+                        } x_ary;
+                } x_fcnary;
+                char x_tvndx[2];                /* tv index */
+        } x_sym;
+
+        union {
+                char x_fname[E_FILNMLEN];
+                struct {
+                        char x_zeroes[4];
+                        char x_offset[4];
+                } x_n;
+        } x_file;
+
+        struct {
+                char x_scnlen[4];                       /* section length */
+                char x_nreloc[2];       /* # relocation entries */
+                char x_nlinno[2];       /* # line numbers */
+        } x_scn;
+
+        struct {
+                char x_tvfill[4];       /* tv fill value */
+                char x_tvlen[2];        /* length of .tv */
+                char x_tvran[2][2];     /* tv range */
+        } x_tv;         /* info about .tv section (in auxent of symbol .tv)) */
+
+        struct {
+                unsigned char x_scnlen[4];
+                unsigned char x_parmhash[4];
+                unsigned char x_snhash[2];
+                unsigned char x_smtyp[1];
+                unsigned char x_smclas[1];
+                unsigned char x_stab[4];
+                unsigned char x_snstab[2];
+        } x_csect;
+
+};
+
+#define SYMENT  struct external_syment
+#define SYMESZ  18
+#define AUXENT  union external_auxent
+#define AUXESZ  18
+#define DBXMASK 0x80            /* for dbx storage mask */
+#define SYMNAME_IN_DEBUG(symptr) ((symptr)->n_sclass & DBXMASK)
+
+
+
+/********************** RELOCATION DIRECTIVES **********************/
+
+
+struct external_reloc {
+  char r_vaddr[4];
+  char r_symndx[4];
+  char r_size[1];
+  char r_type[1];
+};
+
+
+#define RELOC struct external_reloc
+#define RELSZ 10
+
+#define DEFAULT_DATA_SECTION_ALIGNMENT 4
+#define DEFAULT_BSS_SECTION_ALIGNMENT 4
+#define DEFAULT_TEXT_SECTION_ALIGNMENT 4
+/* For new sections we havn't heard of before */
+#define DEFAULT_SECTION_ALIGNMENT 4
diff --git a/arch/powerpc/boot/stdio.c b/arch/powerpc/boot/stdio.c
new file mode 100644
index 000000000000..b5aa522f8b77
--- /dev/null
+++ b/arch/powerpc/boot/stdio.c
@@ -0,0 +1,325 @@
+/*
+ * Copyright (C) Paul Mackerras 1997.
+ *
+ * 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 <stdarg.h>
+#include <stddef.h>
+#include "string.h"
+#include "stdio.h"
+#include "prom.h"
+
+size_t strnlen(const char * s, size_t count)
+{
+        const char *sc;
+
+        for (sc = s; count-- && *sc != '\0'; ++sc)
+                /* nothing */;
+        return sc - s;
+}
+
+extern unsigned int __div64_32(unsigned long long *dividend,
+                               unsigned int divisor);
+
+/* The unnecessary pointer compare is there
+ * to check for type safety (n must be 64bit)
+ */
+# define do_div(n,base) ({                                              \
+        unsigned int __base = (base);                                   \
+        unsigned int __rem;                                             \
+        (void)(((typeof((n)) *)0) == ((unsigned long long *)0));        \
+        if (((n) >> 32) == 0) {                                         \
+                __rem = (unsigned int)(n) % __base;                     \
+                (n) = (unsigned int)(n) / __base;                       \
+        } else                                                          \
+                __rem = __div64_32(&(n), __base);                       \
+        __rem;                                                          \
+ })
+
+static int skip_atoi(const char **s)
+{
+        int i, c;
+
+        for (i = 0; '0' <= (c = **s) && c <= '9'; ++*s)
+                i = i*10 + c - '0';
+        return i;
+}
+
+#define ZEROPAD 1               /* pad with zero */
+#define SIGN    2               /* unsigned/signed long */
+#define PLUS    4               /* show plus */
+#define SPACE   8               /* space if plus */
+#define LEFT    16              /* left justified */
+#define SPECIAL 32              /* 0x */
+#define LARGE   64              /* use 'ABCDEF' instead of 'abcdef' */
+
+static char * number(char * str, unsigned long long num, int base, int size, int precision, int type)
+{
+        char c,sign,tmp[66];
+        const char *digits="0123456789abcdefghijklmnopqrstuvwxyz";
+        int i;
+
+        if (type & LARGE)
+                digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        if (type & LEFT)
+                type &= ~ZEROPAD;
+        if (base < 2 || base > 36)
+                return 0;
+        c = (type & ZEROPAD) ? '0' : ' ';
+        sign = 0;
+        if (type & SIGN) {
+                if ((signed long long)num < 0) {
+                        sign = '-';
+                        num = - (signed long long)num;
+                        size--;
+                } else if (type & PLUS) {
+                        sign = '+';
+                        size--;
+                } else if (type & SPACE) {
+                        sign = ' ';
+                        size--;
+                }
+        }
+        if (type & SPECIAL) {
+                if (base == 16)
+                        size -= 2;
+                else if (base == 8)
+                        size--;
+        }
+        i = 0;
+        if (num == 0)
+                tmp[i++]='0';
+        else while (num != 0) {
+                tmp[i++] = digits[do_div(num, base)];
+        }
+        if (i > precision)
+                precision = i;
+        size -= precision;
+        if (!(type&(ZEROPAD+LEFT)))
+                while(size-->0)
+                        *str++ = ' ';
+        if (sign)
+                *str++ = sign;
+        if (type & SPECIAL) {
+                if (base==8)
+                        *str++ = '0';
+                else if (base==16) {
+                        *str++ = '0';
+                        *str++ = digits[33];
+                }
+        }
+        if (!(type & LEFT))
+                while (size-- > 0)
+                        *str++ = c;
+        while (i < precision--)
+                *str++ = '0';
+        while (i-- > 0)
+                *str++ = tmp[i];
+        while (size-- > 0)
+                *str++ = ' ';
+        return str;
+}
+
+int vsprintf(char *buf, const char *fmt, va_list args)
+{
+        int len;
+        unsigned long long num;
+        int i, base;
+        char * str;
+        const char *s;
+
+        int flags;              /* flags to number() */
+
+        int field_width;        /* width of output field */
+        int precision;          /* min. # of digits for integers; max
+                                   number of chars for from string */
+        int qualifier;          /* 'h', 'l', or 'L' for integer fields */
+                                /* 'z' support added 23/7/1999 S.H.    */
+                                /* 'z' changed to 'Z' --davidm 1/25/99 */
+
+        
+        for (str=buf ; *fmt ; ++fmt) {
+                if (*fmt != '%') {
+                        *str++ = *fmt;
+                        continue;
+                }
+                        
+                /* process flags */
+                flags = 0;
+                repeat:
+                        ++fmt;          /* this also skips first '%' */
+                        switch (*fmt) {
+                                case '-': flags |= LEFT; goto repeat;
+                                case '+': flags |= PLUS; goto repeat;
+                                case ' ': flags |= SPACE; goto repeat;
+                                case '#': flags |= SPECIAL; goto repeat;
+                                case '0': flags |= ZEROPAD; goto repeat;
+                                }
+                
+                /* get field width */
+                field_width = -1;
+                if ('0' <= *fmt && *fmt <= '9')
+                        field_width = skip_atoi(&fmt);
+                else if (*fmt == '*') {
+                        ++fmt;
+                        /* it's the next argument */
+                        field_width = va_arg(args, int);
+                        if (field_width < 0) {
+                                field_width = -field_width;
+                                flags |= LEFT;
+                        }
+                }
+
+                /* get the precision */
+                precision = -1;
+                if (*fmt == '.') {
+                        ++fmt;  
+                        if ('0' <= *fmt && *fmt <= '9')
+                                precision = skip_atoi(&fmt);
+                        else if (*fmt == '*') {
+                                ++fmt;
+                                /* it's the next argument */
+                                precision = va_arg(args, int);
+                        }
+                        if (precision < 0)
+                                precision = 0;
+                }
+
+                /* get the conversion qualifier */
+                qualifier = -1;
+                if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || *fmt =='Z') {
+                        qualifier = *fmt;
+                        ++fmt;
+                }
+
+                /* default base */
+                base = 10;
+
+                switch (*fmt) {
+                case 'c':
+                        if (!(flags & LEFT))
+                                while (--field_width > 0)
+                                        *str++ = ' ';
+                        *str++ = (unsigned char) va_arg(args, int);
+                        while (--field_width > 0)
+                                *str++ = ' ';
+                        continue;
+
+                case 's':
+                        s = va_arg(args, char *);
+                        if (!s)
+                                s = "<NULL>";
+
+                        len = strnlen(s, precision);
+
+                        if (!(flags & LEFT))
+                                while (len < field_width--)
+                                        *str++ = ' ';
+                        for (i = 0; i < len; ++i)
+                                *str++ = *s++;
+                        while (len < field_width--)
+                                *str++ = ' ';
+                        continue;
+
+                case 'p':
+                        if (field_width == -1) {
+                                field_width = 2*sizeof(void *);
+                                flags |= ZEROPAD;
+                        }
+                        str = number(str,
+                                (unsigned long) va_arg(args, void *), 16,
+                                field_width, precision, flags);
+                        continue;
+
+
+                case 'n':
+                        if (qualifier == 'l') {
+                                long * ip = va_arg(args, long *);
+                                *ip = (str - buf);
+                        } else if (qualifier == 'Z') {
+                                size_t * ip = va_arg(args, size_t *);
+                                *ip = (str - buf);
+                        } else {
+                                int * ip = va_arg(args, int *);
+                                *ip = (str - buf);
+                        }
+                        continue;
+
+                case '%':
+                        *str++ = '%';
+                        continue;
+
+                /* integer number formats - set up the flags and "break" */
+                case 'o':
+                        base = 8;
+                        break;
+
+                case 'X':
+                        flags |= LARGE;
+                case 'x':
+                        base = 16;
+                        break;
+
+                case 'd':
+                case 'i':
+                        flags |= SIGN;
+                case 'u':
+                        break;
+
+                default:
+                        *str++ = '%';
+                        if (*fmt)
+                                *str++ = *fmt;
+                        else
+                                --fmt;
+                        continue;
+                }
+                if (qualifier == 'l') {
+                        num = va_arg(args, unsigned long);
+                        if (flags & SIGN)
+                                num = (signed long) num;
+                } else if (qualifier == 'Z') {
+                        num = va_arg(args, size_t);
+                } else if (qualifier == 'h') {
+                        num = (unsigned short) va_arg(args, int);
+                        if (flags & SIGN)
+                                num = (signed short) num;
+                } else {
+                        num = va_arg(args, unsigned int);
+                        if (flags & SIGN)
+                                num = (signed int) num;
+                }
+                str = number(str, num, base, field_width, precision, flags);
+        }
+        *str = '\0';
+        return str-buf;
+}
+
+int sprintf(char * buf, const char *fmt, ...)
+{
+        va_list args;
+        int i;
+
+        va_start(args, fmt);
+        i=vsprintf(buf,fmt,args);
+        va_end(args);
+        return i;
+}
+
+static char sprint_buf[1024];
+
+int
+printf(const 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);
+        return n;
+}
diff --git a/arch/powerpc/boot/stdio.h b/arch/powerpc/boot/stdio.h
index 24bd3a8dee94..eb9e16c87aef 100644
--- a/arch/powerpc/boot/stdio.h
+++ b/arch/powerpc/boot/stdio.h
@@ -7,10 +7,4 @@ extern int sprintf(char *buf, const char *fmt, ...);
 
 extern int vsprintf(char *buf, const char *fmt, va_list args);
 
-extern int putc(int c, void *f);
-extern int putchar(int c);
-extern int getchar(void);
-
-extern int fputs(char *str, void *f);
-
 #endif                          /* _PPC_BOOT_STDIO_H_ */
diff --git a/arch/powerpc/boot/string.S b/arch/powerpc/boot/string.S
index b1eeaed7db17..ac3d43b6a324 100644
--- a/arch/powerpc/boot/string.S
+++ b/arch/powerpc/boot/string.S
@@ -107,10 +107,12 @@ memcpy:
         rlwinm. r7,r5,32-3,3,31         /* r7 = r5 >> 3 */
         addi    r6,r3,-4
         addi    r4,r4,-4
-        beq     2f                      /* if less than 8 bytes to do */
+        beq     3f                      /* if less than 8 bytes to do */
         andi.   r0,r6,3                 /* get dest word aligned */
         mtctr   r7
         bne     5f
+        andi.   r0,r4,3                 /* check src word aligned too */
+        bne     3f
 1:      lwz     r7,4(r4)
         lwzu    r8,8(r4)
         stw     r7,4(r6)
@@ -132,6 +134,11 @@ memcpy:
         bdnz    4b
         blr
 5:      subfic  r0,r0,4
+        cmpw    cr1,r0,r5
+        add     r7,r0,r4
+        andi.   r7,r7,3                 /* will source be word-aligned too? */
+        ble     cr1,3b
+        bne     3b                      /* do byte-by-byte if not */
         mtctr   r0
 6:      lbz     r7,4(r4)
         addi    r4,r4,1
@@ -149,10 +156,12 @@ backwards_memcpy:
         rlwinm. r7,r5,32-3,3,31         /* r7 = r5 >> 3 */
         add     r6,r3,r5
         add     r4,r4,r5
-        beq     2f
+        beq     3f
         andi.   r0,r6,3
         mtctr   r7
         bne     5f
+        andi.   r0,r4,3
+        bne     3f
 1:      lwz     r7,-4(r4)
         lwzu    r8,-8(r4)
         stw     r7,-4(r6)
@@ -171,7 +180,12 @@ backwards_memcpy:
         stbu    r0,-1(r6)
         bdnz    4b
         blr
-5:      mtctr   r0
+5:      cmpw    cr1,r0,r5
+        subf    r7,r0,r4
+        andi.   r7,r7,3
+        ble     cr1,3b
+        bne     3b
+        mtctr   r0
 6:      lbzu    r7,-1(r4)
         stbu    r7,-1(r6)
         bdnz    6b
diff --git a/arch/powerpc/boot/zImage.coff.lds b/arch/powerpc/boot/zImage.coff.lds
new file mode 100644
index 000000000000..6016251a1a2c
--- /dev/null
+++ b/arch/powerpc/boot/zImage.coff.lds
@@ -0,0 +1,46 @@
+OUTPUT_ARCH(powerpc:common)
+ENTRY(_start)
+SECTIONS
+{
+  . = (5*1024*1024);
+  _start = .;
+  .text      :
+  {
+    *(.text)
+    *(.fixup)
+  }
+  _etext = .;
+  . = ALIGN(4096);
+  .data    :
+  {
+    *(.rodata*)
+    *(.data*)
+    *(.sdata*)
+    __got2_start = .;
+    *(.got2)
+    __got2_end = .;
+
+    _vmlinux_start =  .;
+    *(.kernel:vmlinux.strip)
+    _vmlinux_end =  .;
+
+    _initrd_start =  .;
+    *(.kernel:initrd)
+    _initrd_end =  .;
+  }
+
+  . = ALIGN(4096);
+  _edata  =  .;
+  __bss_start = .;
+  .bss       :
+  {
+   *(.sbss)
+   *(.bss)
+  }
+  _end = . ;
+
+  /DISCARD/ :
+  {
+    *(.comment)
+  }
+}
diff --git a/arch/powerpc/configs/mpc834x_sys_defconfig b/arch/powerpc/configs/mpc834x_sys_defconfig
new file mode 100644
index 000000000000..3bff761965c2
--- /dev/null
+++ b/arch/powerpc/configs/mpc834x_sys_defconfig
@@ -0,0 +1,911 @@
+#
+# Automatically generated make config: don't edit
+# Linux kernel version: 2.6.15-g461d4edf-dirty
+# Fri Jan 13 11:01:47 2006
+#
+# CONFIG_PPC64 is not set
+CONFIG_PPC32=y
+CONFIG_PPC_MERGE=y
+CONFIG_MMU=y
+CONFIG_GENERIC_HARDIRQS=y
+CONFIG_RWSEM_XCHGADD_ALGORITHM=y
+CONFIG_GENERIC_CALIBRATE_DELAY=y
+CONFIG_PPC=y
+CONFIG_EARLY_PRINTK=y
+CONFIG_GENERIC_NVRAM=y
+CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER=y
+CONFIG_ARCH_MAY_HAVE_PC_FDC=y
+CONFIG_PPC_OF=y
+CONFIG_PPC_UDBG_16550=y
+# CONFIG_GENERIC_TBSYNC is not set
+CONFIG_DEFAULT_UIMAGE=y
+
+#
+# Processor support
+#
+# CONFIG_CLASSIC32 is not set
+# CONFIG_PPC_52xx is not set
+# CONFIG_PPC_82xx is not set
+CONFIG_PPC_83xx=y
+# CONFIG_40x is not set
+# CONFIG_44x is not set
+# CONFIG_8xx is not set
+# CONFIG_E200 is not set
+# CONFIG_E500 is not set
+CONFIG_6xx=y
+CONFIG_83xx=y
+CONFIG_PPC_FPU=y
+CONFIG_PPC_STD_MMU=y
+CONFIG_PPC_STD_MMU_32=y
+# CONFIG_SMP is not set
+
+#
+# Code maturity level options
+#
+CONFIG_EXPERIMENTAL=y
+CONFIG_CLEAN_COMPILE=y
+CONFIG_BROKEN_ON_SMP=y
+CONFIG_INIT_ENV_ARG_LIMIT=32
+
+#
+# General setup
+#
+CONFIG_LOCALVERSION=""
+CONFIG_LOCALVERSION_AUTO=y
+CONFIG_SWAP=y
+CONFIG_SYSVIPC=y
+# CONFIG_POSIX_MQUEUE is not set
+# CONFIG_BSD_PROCESS_ACCT is not set
+CONFIG_SYSCTL=y
+# CONFIG_AUDIT is not set
+# CONFIG_IKCONFIG is not set
+CONFIG_INITRAMFS_SOURCE=""
+# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
+CONFIG_EMBEDDED=y
+# CONFIG_KALLSYMS is not set
+CONFIG_HOTPLUG=y
+CONFIG_PRINTK=y
+CONFIG_BUG=y
+CONFIG_ELF_CORE=y
+CONFIG_BASE_FULL=y
+CONFIG_FUTEX=y
+# CONFIG_EPOLL is not set
+CONFIG_SHMEM=y
+CONFIG_CC_ALIGN_FUNCTIONS=0
+CONFIG_CC_ALIGN_LABELS=0
+CONFIG_CC_ALIGN_LOOPS=0
+CONFIG_CC_ALIGN_JUMPS=0
+CONFIG_SLAB=y
+# CONFIG_TINY_SHMEM is not set
+CONFIG_BASE_SMALL=0
+# CONFIG_SLOB is not set
+
+#
+# Loadable module support
+#
+CONFIG_MODULES=y
+CONFIG_MODULE_UNLOAD=y
+# CONFIG_MODULE_FORCE_UNLOAD is not set
+CONFIG_OBSOLETE_MODPARM=y
+# CONFIG_MODVERSIONS is not set
+# CONFIG_MODULE_SRCVERSION_ALL is not set
+# CONFIG_KMOD is not set
+
+#
+# Block layer
+#
+# CONFIG_LBD is not set
+
+#
+# IO Schedulers
+#
+CONFIG_IOSCHED_NOOP=y
+CONFIG_IOSCHED_AS=y
+CONFIG_IOSCHED_DEADLINE=y
+CONFIG_IOSCHED_CFQ=y
+CONFIG_DEFAULT_AS=y
+# CONFIG_DEFAULT_DEADLINE is not set
+# CONFIG_DEFAULT_CFQ is not set
+# CONFIG_DEFAULT_NOOP is not set
+CONFIG_DEFAULT_IOSCHED="anticipatory"
+CONFIG_PPC_GEN550=y
+# CONFIG_WANT_EARLY_SERIAL is not set
+
+#
+# Platform support
+#
+CONFIG_MPC834x_SYS=y
+CONFIG_MPC834x=y
+
+#
+# Kernel options
+#
+# CONFIG_HIGHMEM is not set
+# CONFIG_HZ_100 is not set
+CONFIG_HZ_250=y
+# CONFIG_HZ_1000 is not set
+CONFIG_HZ=250
+CONFIG_PREEMPT_NONE=y
+# CONFIG_PREEMPT_VOLUNTARY is not set
+# CONFIG_PREEMPT is not set
+CONFIG_BINFMT_ELF=y
+# CONFIG_BINFMT_MISC is not set
+CONFIG_ARCH_FLATMEM_ENABLE=y
+CONFIG_SELECT_MEMORY_MODEL=y
+CONFIG_FLATMEM_MANUAL=y
+# CONFIG_DISCONTIGMEM_MANUAL is not set
+# CONFIG_SPARSEMEM_MANUAL is not set
+CONFIG_FLATMEM=y
+CONFIG_FLAT_NODE_MEM_MAP=y
+# CONFIG_SPARSEMEM_STATIC is not set
+CONFIG_SPLIT_PTLOCK_CPUS=4
+CONFIG_PROC_DEVICETREE=y
+# CONFIG_CMDLINE_BOOL is not set
+# CONFIG_PM is not set
+# CONFIG_SOFTWARE_SUSPEND is not set
+CONFIG_SECCOMP=y
+CONFIG_ISA_DMA_API=y
+
+#
+# Bus options
+#
+CONFIG_GENERIC_ISA_DMA=y
+# CONFIG_PPC_I8259 is not set
+CONFIG_PPC_INDIRECT_PCI=y
+CONFIG_FSL_SOC=y
+CONFIG_PCI=y
+CONFIG_PCI_DOMAINS=y
+# CONFIG_PCI_LEGACY_PROC is not set
+
+#
+# PCCARD (PCMCIA/CardBus) support
+#
+# CONFIG_PCCARD is not set
+
+#
+# PCI Hotplug Support
+#
+# CONFIG_HOTPLUG_PCI is not set
+
+#
+# Advanced setup
+#
+# CONFIG_ADVANCED_OPTIONS is not set
+
+#
+# Default settings for advanced configuration options are used
+#
+CONFIG_HIGHMEM_START=0xfe000000
+CONFIG_LOWMEM_SIZE=0x30000000
+CONFIG_KERNEL_START=0xc0000000
+CONFIG_TASK_SIZE=0x80000000
+CONFIG_BOOT_LOAD=0x00800000
+
+#
+# Networking
+#
+CONFIG_NET=y
+
+#
+# Networking options
+#
+CONFIG_PACKET=y
+# CONFIG_PACKET_MMAP is not set
+CONFIG_UNIX=y
+# CONFIG_NET_KEY is not set
+CONFIG_INET=y
+CONFIG_IP_MULTICAST=y
+# CONFIG_IP_ADVANCED_ROUTER is not set
+CONFIG_IP_FIB_HASH=y
+CONFIG_IP_PNP=y
+CONFIG_IP_PNP_DHCP=y
+CONFIG_IP_PNP_BOOTP=y
+# CONFIG_IP_PNP_RARP is not set
+# CONFIG_NET_IPIP is not set
+# CONFIG_NET_IPGRE is not set
+# CONFIG_IP_MROUTE is not set
+# CONFIG_ARPD is not set
+CONFIG_SYN_COOKIES=y
+# CONFIG_INET_AH is not set
+# CONFIG_INET_ESP is not set
+# CONFIG_INET_IPCOMP is not set
+# CONFIG_INET_TUNNEL is not set
+CONFIG_INET_DIAG=y
+CONFIG_INET_TCP_DIAG=y
+# CONFIG_TCP_CONG_ADVANCED is not set
+CONFIG_TCP_CONG_BIC=y
+# CONFIG_IPV6 is not set
+# CONFIG_NETFILTER is not set
+
+#
+# DCCP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_DCCP is not set
+
+#
+# SCTP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_SCTP is not set
+# CONFIG_ATM is not set
+# CONFIG_BRIDGE is not set
+# CONFIG_VLAN_8021Q is not set
+# CONFIG_DECNET is not set
+# CONFIG_LLC2 is not set
+# CONFIG_IPX is not set
+# CONFIG_ATALK is not set
+# CONFIG_X25 is not set
+# CONFIG_LAPB is not set
+# CONFIG_NET_DIVERT is not set
+# CONFIG_ECONET is not set
+# CONFIG_WAN_ROUTER is not set
+
+#
+# QoS and/or fair queueing
+#
+# CONFIG_NET_SCHED is not set
+
+#
+# Network testing
+#
+# CONFIG_NET_PKTGEN is not set
+# CONFIG_HAMRADIO is not set
+# CONFIG_IRDA is not set
+# CONFIG_BT is not set
+# CONFIG_IEEE80211 is not set
+
+#
+# Device Drivers
+#
+
+#
+# Generic Driver Options
+#
+CONFIG_STANDALONE=y
+CONFIG_PREVENT_FIRMWARE_BUILD=y
+# CONFIG_FW_LOADER is not set
+
+#
+# Connector - unified userspace <-> kernelspace linker
+#
+# CONFIG_CONNECTOR is not set
+
+#
+# Memory Technology Devices (MTD)
+#
+# CONFIG_MTD is not set
+
+#
+# Parallel port support
+#
+# CONFIG_PARPORT is not set
+
+#
+# Plug and Play support
+#
+
+#
+# Block devices
+#
+# CONFIG_BLK_DEV_FD is not set
+# CONFIG_BLK_CPQ_DA is not set
+# CONFIG_BLK_CPQ_CISS_DA is not set
+# CONFIG_BLK_DEV_DAC960 is not set
+# CONFIG_BLK_DEV_UMEM is not set
+# CONFIG_BLK_DEV_COW_COMMON is not set
+CONFIG_BLK_DEV_LOOP=y
+# CONFIG_BLK_DEV_CRYPTOLOOP is not set
+# CONFIG_BLK_DEV_NBD is not set
+# CONFIG_BLK_DEV_SX8 is not set
+CONFIG_BLK_DEV_RAM=y
+CONFIG_BLK_DEV_RAM_COUNT=16
+CONFIG_BLK_DEV_RAM_SIZE=32768
+CONFIG_BLK_DEV_INITRD=y
+# CONFIG_CDROM_PKTCDVD is not set
+# CONFIG_ATA_OVER_ETH is not set
+
+#
+# ATA/ATAPI/MFM/RLL support
+#
+# CONFIG_IDE is not set
+
+#
+# SCSI device support
+#
+# CONFIG_RAID_ATTRS is not set
+# CONFIG_SCSI is not set
+
+#
+# Multi-device support (RAID and LVM)
+#
+# CONFIG_MD is not set
+
+#
+# Fusion MPT device support
+#
+# CONFIG_FUSION is not set
+
+#
+# IEEE 1394 (FireWire) support
+#
+# CONFIG_IEEE1394 is not set
+
+#
+# I2O device support
+#
+# CONFIG_I2O is not set
+
+#
+# Macintosh device drivers
+#
+# CONFIG_WINDFARM is not set
+
+#
+# Network device support
+#
+CONFIG_NETDEVICES=y
+# CONFIG_DUMMY is not set
+# CONFIG_BONDING is not set
+# CONFIG_EQUALIZER is not set
+# CONFIG_TUN is not set
+
+#
+# ARCnet devices
+#
+# CONFIG_ARCNET is not set
+
+#
+# PHY device support
+#
+CONFIG_PHYLIB=y
+
+#
+# MII PHY device drivers
+#
+CONFIG_MARVELL_PHY=y
+# CONFIG_DAVICOM_PHY is not set
+# CONFIG_QSEMI_PHY is not set
+# CONFIG_LXT_PHY is not set
+# CONFIG_CICADA_PHY is not set
+
+#
+# Ethernet (10 or 100Mbit)
+#
+CONFIG_NET_ETHERNET=y
+CONFIG_MII=y
+# CONFIG_HAPPYMEAL is not set
+# CONFIG_SUNGEM is not set
+# CONFIG_CASSINI is not set
+# CONFIG_NET_VENDOR_3COM is not set
+
+#
+# Tulip family network device support
+#
+# CONFIG_NET_TULIP is not set
+# CONFIG_HP100 is not set
+CONFIG_NET_PCI=y
+# CONFIG_PCNET32 is not set
+# CONFIG_AMD8111_ETH is not set
+# CONFIG_ADAPTEC_STARFIRE is not set
+# CONFIG_B44 is not set
+# CONFIG_FORCEDETH is not set
+# CONFIG_DGRS is not set
+# CONFIG_EEPRO100 is not set
+CONFIG_E100=y
+# CONFIG_FEALNX is not set
+# CONFIG_NATSEMI is not set
+# CONFIG_NE2K_PCI is not set
+# CONFIG_8139CP is not set
+# CONFIG_8139TOO is not set
+# CONFIG_SIS900 is not set
+# CONFIG_EPIC100 is not set
+# CONFIG_SUNDANCE is not set
+# CONFIG_TLAN is not set
+# CONFIG_VIA_RHINE is not set
+
+#
+# Ethernet (1000 Mbit)
+#
+# CONFIG_ACENIC is not set
+# CONFIG_DL2K is not set
+# CONFIG_E1000 is not set
+# CONFIG_NS83820 is not set
+# CONFIG_HAMACHI is not set
+# CONFIG_YELLOWFIN is not set
+# CONFIG_R8169 is not set
+# CONFIG_SIS190 is not set
+# CONFIG_SKGE is not set
+# CONFIG_SKY2 is not set
+# CONFIG_SK98LIN is not set
+# CONFIG_VIA_VELOCITY is not set
+# CONFIG_TIGON3 is not set
+# CONFIG_BNX2 is not set
+CONFIG_GIANFAR=y
+# CONFIG_GFAR_NAPI is not set
+
+#
+# Ethernet (10000 Mbit)
+#
+# CONFIG_CHELSIO_T1 is not set
+# CONFIG_IXGB is not set
+# CONFIG_S2IO is not set
+
+#
+# Token Ring devices
+#
+# CONFIG_TR is not set
+
+#
+# Wireless LAN (non-hamradio)
+#
+# CONFIG_NET_RADIO is not set
+
+#
+# Wan interfaces
+#
+# CONFIG_WAN is not set
+# CONFIG_FDDI is not set
+# CONFIG_HIPPI is not set
+# CONFIG_PPP is not set
+# CONFIG_SLIP is not set
+# CONFIG_SHAPER is not set
+# CONFIG_NETCONSOLE is not set
+# CONFIG_NETPOLL is not set
+# CONFIG_NET_POLL_CONTROLLER is not set
+
+#
+# ISDN subsystem
+#
+# CONFIG_ISDN is not set
+
+#
+# Telephony Support
+#
+# CONFIG_PHONE is not set
+
+#
+# Input device support
+#
+CONFIG_INPUT=y
+
+#
+# Userland interfaces
+#
+# CONFIG_INPUT_MOUSEDEV is not set
+# CONFIG_INPUT_JOYDEV is not set
+# CONFIG_INPUT_TSDEV is not set
+# CONFIG_INPUT_EVDEV is not set
+# CONFIG_INPUT_EVBUG is not set
+
+#
+# Input Device Drivers
+#
+# CONFIG_INPUT_KEYBOARD is not set
+# CONFIG_INPUT_MOUSE is not set
+# CONFIG_INPUT_JOYSTICK is not set
+# CONFIG_INPUT_TOUCHSCREEN is not set
+# CONFIG_INPUT_MISC is not set
+
+#
+# Hardware I/O ports
+#
+# CONFIG_SERIO is not set
+# CONFIG_GAMEPORT is not set
+
+#
+# Character devices
+#
+# CONFIG_VT is not set
+# CONFIG_SERIAL_NONSTANDARD is not set
+
+#
+# Serial drivers
+#
+CONFIG_SERIAL_8250=y
+CONFIG_SERIAL_8250_CONSOLE=y
+CONFIG_SERIAL_8250_NR_UARTS=4
+CONFIG_SERIAL_8250_RUNTIME_UARTS=4
+# CONFIG_SERIAL_8250_EXTENDED is not set
+
+#
+# Non-8250 serial port support
+#
+CONFIG_SERIAL_CORE=y
+CONFIG_SERIAL_CORE_CONSOLE=y
+CONFIG_UNIX98_PTYS=y
+CONFIG_LEGACY_PTYS=y
+CONFIG_LEGACY_PTY_COUNT=256
+
+#
+# IPMI
+#
+# CONFIG_IPMI_HANDLER is not set
+
+#
+# Watchdog Cards
+#
+CONFIG_WATCHDOG=y
+# CONFIG_WATCHDOG_NOWAYOUT is not set
+
+#
+# Watchdog Device Drivers
+#
+# CONFIG_SOFT_WATCHDOG is not set
+CONFIG_83xx_WDT=y
+
+#
+# PCI-based Watchdog Cards
+#
+# CONFIG_PCIPCWATCHDOG is not set
+# CONFIG_WDTPCI is not set
+# CONFIG_NVRAM is not set
+CONFIG_GEN_RTC=y
+# CONFIG_GEN_RTC_X is not set
+# CONFIG_DTLK is not set
+# CONFIG_R3964 is not set
+# CONFIG_APPLICOM is not set
+
+#
+# Ftape, the floppy tape device driver
+#
+# CONFIG_AGP is not set
+# CONFIG_DRM is not set
+# CONFIG_RAW_DRIVER is not set
+
+#
+# TPM devices
+#
+# CONFIG_TCG_TPM is not set
+# CONFIG_TELCLOCK is not set
+
+#
+# I2C support
+#
+CONFIG_I2C=y
+CONFIG_I2C_CHARDEV=y
+
+#
+# I2C Algorithms
+#
+# CONFIG_I2C_ALGOBIT is not set
+# CONFIG_I2C_ALGOPCF is not set
+# CONFIG_I2C_ALGOPCA is not set
+
+#
+# I2C Hardware Bus support
+#
+# CONFIG_I2C_ALI1535 is not set
+# CONFIG_I2C_ALI1563 is not set
+# CONFIG_I2C_ALI15X3 is not set
+# CONFIG_I2C_AMD756 is not set
+# CONFIG_I2C_AMD8111 is not set
+# CONFIG_I2C_I801 is not set
+# CONFIG_I2C_I810 is not set
+# CONFIG_I2C_PIIX4 is not set
+CONFIG_I2C_MPC=y
+# CONFIG_I2C_NFORCE2 is not set
+# CONFIG_I2C_PARPORT_LIGHT is not set
+# CONFIG_I2C_PROSAVAGE is not set
+# CONFIG_I2C_SAVAGE4 is not set
+# CONFIG_SCx200_ACB is not set
+# CONFIG_I2C_SIS5595 is not set
+# CONFIG_I2C_SIS630 is not set
+# CONFIG_I2C_SIS96X is not set
+# CONFIG_I2C_STUB is not set
+# CONFIG_I2C_VIA is not set
+# CONFIG_I2C_VIAPRO is not set
+# CONFIG_I2C_VOODOO3 is not set
+# CONFIG_I2C_PCA_ISA is not set
+
+#
+# Miscellaneous I2C Chip support
+#
+# CONFIG_SENSORS_DS1337 is not set
+# CONFIG_SENSORS_DS1374 is not set
+# CONFIG_SENSORS_EEPROM is not set
+# CONFIG_SENSORS_PCF8574 is not set
+# CONFIG_SENSORS_PCA9539 is not set
+# CONFIG_SENSORS_PCF8591 is not set
+# CONFIG_SENSORS_RTC8564 is not set
+# CONFIG_SENSORS_M41T00 is not set
+# CONFIG_SENSORS_MAX6875 is not set
+# CONFIG_RTC_X1205_I2C is not set
+# CONFIG_I2C_DEBUG_CORE is not set
+# CONFIG_I2C_DEBUG_ALGO is not set
+# CONFIG_I2C_DEBUG_BUS is not set
+# CONFIG_I2C_DEBUG_CHIP is not set
+
+#
+# Dallas's 1-wire bus
+#
+# CONFIG_W1 is not set
+
+#
+# Hardware Monitoring support
+#
+CONFIG_HWMON=y
+# CONFIG_HWMON_VID is not set
+# CONFIG_SENSORS_ADM1021 is not set
+# CONFIG_SENSORS_ADM1025 is not set
+# CONFIG_SENSORS_ADM1026 is not set
+# CONFIG_SENSORS_ADM1031 is not set
+# CONFIG_SENSORS_ADM9240 is not set
+# CONFIG_SENSORS_ASB100 is not set
+# CONFIG_SENSORS_ATXP1 is not set
+# CONFIG_SENSORS_DS1621 is not set
+# CONFIG_SENSORS_FSCHER is not set
+# CONFIG_SENSORS_FSCPOS is not set
+# CONFIG_SENSORS_GL518SM is not set
+# CONFIG_SENSORS_GL520SM is not set
+# CONFIG_SENSORS_IT87 is not set
+# CONFIG_SENSORS_LM63 is not set
+# CONFIG_SENSORS_LM75 is not set
+# CONFIG_SENSORS_LM77 is not set
+# CONFIG_SENSORS_LM78 is not set
+# CONFIG_SENSORS_LM80 is not set
+# CONFIG_SENSORS_LM83 is not set
+# CONFIG_SENSORS_LM85 is not set
+# CONFIG_SENSORS_LM87 is not set
+# CONFIG_SENSORS_LM90 is not set
+# CONFIG_SENSORS_LM92 is not set
+# CONFIG_SENSORS_MAX1619 is not set
+# CONFIG_SENSORS_PC87360 is not set
+# CONFIG_SENSORS_SIS5595 is not set
+# CONFIG_SENSORS_SMSC47M1 is not set
+# CONFIG_SENSORS_SMSC47B397 is not set
+# CONFIG_SENSORS_VIA686A is not set
+# CONFIG_SENSORS_VT8231 is not set
+# CONFIG_SENSORS_W83781D is not set
+# CONFIG_SENSORS_W83792D is not set
+# CONFIG_SENSORS_W83L785TS is not set
+# CONFIG_SENSORS_W83627HF is not set
+# CONFIG_SENSORS_W83627EHF is not set
+# CONFIG_HWMON_DEBUG_CHIP is not set
+
+#
+# Misc devices
+#
+
+#
+# Multimedia Capabilities Port drivers
+#
+
+#
+# Multimedia devices
+#
+# CONFIG_VIDEO_DEV is not set
+
+#
+# Digital Video Broadcasting Devices
+#
+# CONFIG_DVB is not set
+
+#
+# Graphics support
+#
+# CONFIG_FB is not set
+
+#
+# Sound
+#
+# CONFIG_SOUND is not set
+
+#
+# USB support
+#
+CONFIG_USB_ARCH_HAS_HCD=y
+CONFIG_USB_ARCH_HAS_OHCI=y
+# CONFIG_USB is not set
+
+#
+# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
+#
+
+#
+# USB Gadget Support
+#
+# CONFIG_USB_GADGET is not set
+
+#
+# MMC/SD Card support
+#
+# CONFIG_MMC is not set
+
+#
+# InfiniBand support
+#
+# CONFIG_INFINIBAND is not set
+
+#
+# SN Devices
+#
+
+#
+# File systems
+#
+CONFIG_EXT2_FS=y
+# CONFIG_EXT2_FS_XATTR is not set
+# CONFIG_EXT2_FS_XIP is not set
+CONFIG_EXT3_FS=y
+CONFIG_EXT3_FS_XATTR=y
+# CONFIG_EXT3_FS_POSIX_ACL is not set
+# CONFIG_EXT3_FS_SECURITY is not set
+CONFIG_JBD=y
+# CONFIG_JBD_DEBUG is not set
+CONFIG_FS_MBCACHE=y
+# CONFIG_REISERFS_FS is not set
+# CONFIG_JFS_FS is not set
+# CONFIG_FS_POSIX_ACL is not set
+# CONFIG_XFS_FS is not set
+# CONFIG_OCFS2_FS is not set
+# CONFIG_MINIX_FS is not set
+# CONFIG_ROMFS_FS is not set
+CONFIG_INOTIFY=y
+# CONFIG_QUOTA is not set
+CONFIG_DNOTIFY=y
+# CONFIG_AUTOFS_FS is not set
+# CONFIG_AUTOFS4_FS is not set
+# CONFIG_FUSE_FS is not set
+
+#
+# CD-ROM/DVD Filesystems
+#
+# CONFIG_ISO9660_FS is not set
+# CONFIG_UDF_FS is not set
+
+#
+# DOS/FAT/NT Filesystems
+#
+# CONFIG_MSDOS_FS is not set
+# CONFIG_VFAT_FS is not set
+# CONFIG_NTFS_FS is not set
+
+#
+# Pseudo filesystems
+#
+CONFIG_PROC_FS=y
+CONFIG_PROC_KCORE=y
+CONFIG_SYSFS=y
+CONFIG_TMPFS=y
+# CONFIG_HUGETLB_PAGE is not set
+CONFIG_RAMFS=y
+# CONFIG_RELAYFS_FS is not set
+# CONFIG_CONFIGFS_FS is not set
+
+#
+# Miscellaneous filesystems
+#
+# CONFIG_ADFS_FS is not set
+# CONFIG_AFFS_FS is not set
+# CONFIG_HFS_FS is not set
+# CONFIG_HFSPLUS_FS is not set
+# CONFIG_BEFS_FS is not set
+# CONFIG_BFS_FS is not set
+# CONFIG_EFS_FS is not set
+# CONFIG_CRAMFS is not set
+# CONFIG_VXFS_FS is not set
+# CONFIG_HPFS_FS is not set
+# CONFIG_QNX4FS_FS is not set
+# CONFIG_SYSV_FS is not set
+# CONFIG_UFS_FS is not set
+
+#
+# Network File Systems
+#
+CONFIG_NFS_FS=y
+CONFIG_NFS_V3=y
+# CONFIG_NFS_V3_ACL is not set
+CONFIG_NFS_V4=y
+# CONFIG_NFS_DIRECTIO is not set
+# CONFIG_NFSD is not set
+CONFIG_ROOT_NFS=y
+CONFIG_LOCKD=y
+CONFIG_LOCKD_V4=y
+CONFIG_NFS_COMMON=y
+CONFIG_SUNRPC=y
+CONFIG_SUNRPC_GSS=y
+CONFIG_RPCSEC_GSS_KRB5=y
+# CONFIG_RPCSEC_GSS_SPKM3 is not set
+# CONFIG_SMB_FS is not set
+# CONFIG_CIFS is not set
+# CONFIG_NCP_FS is not set
+# CONFIG_CODA_FS is not set
+# CONFIG_AFS_FS is not set
+# CONFIG_9P_FS is not set
+
+#
+# Partition Types
+#
+CONFIG_PARTITION_ADVANCED=y
+# CONFIG_ACORN_PARTITION is not set
+# CONFIG_OSF_PARTITION is not set
+# CONFIG_AMIGA_PARTITION is not set
+# CONFIG_ATARI_PARTITION is not set
+# CONFIG_MAC_PARTITION is not set
+# CONFIG_MSDOS_PARTITION is not set
+# CONFIG_LDM_PARTITION is not set
+# CONFIG_SGI_PARTITION is not set
+# CONFIG_ULTRIX_PARTITION is not set
+# CONFIG_SUN_PARTITION is not set
+# CONFIG_EFI_PARTITION is not set
+
+#
+# Native Language Support
+#
+# CONFIG_NLS is not set
+
+#
+# Library routines
+#
+# CONFIG_CRC_CCITT is not set
+# CONFIG_CRC16 is not set
+CONFIG_CRC32=y
+# CONFIG_LIBCRC32C is not set
+
+#
+# Instrumentation Support
+#
+# CONFIG_PROFILING is not set
+
+#
+# Kernel hacking
+#
+# CONFIG_PRINTK_TIME is not set
+# CONFIG_MAGIC_SYSRQ is not set
+# CONFIG_DEBUG_KERNEL is not set
+CONFIG_LOG_BUF_SHIFT=14
+# CONFIG_BOOTX_TEXT is not set
+# CONFIG_SERIAL_TEXT_DEBUG is not set
+# CONFIG_PPC_EARLY_DEBUG_LPAR is not set
+# CONFIG_PPC_EARLY_DEBUG_G5 is not set
+# CONFIG_PPC_EARLY_DEBUG_RTAS is not set
+# CONFIG_PPC_EARLY_DEBUG_MAPLE is not set
+# CONFIG_PPC_EARLY_DEBUG_ISERIES is not set
+
+#
+# Security options
+#
+# CONFIG_KEYS is not set
+# CONFIG_SECURITY is not set
+
+#
+# Cryptographic options
+#
+CONFIG_CRYPTO=y
+# CONFIG_CRYPTO_HMAC is not set
+# CONFIG_CRYPTO_NULL is not set
+# CONFIG_CRYPTO_MD4 is not set
+CONFIG_CRYPTO_MD5=y
+# CONFIG_CRYPTO_SHA1 is not set
+# CONFIG_CRYPTO_SHA256 is not set
+# CONFIG_CRYPTO_SHA512 is not set
+# CONFIG_CRYPTO_WP512 is not set
+# CONFIG_CRYPTO_TGR192 is not set
+CONFIG_CRYPTO_DES=y
+# CONFIG_CRYPTO_BLOWFISH is not set
+# CONFIG_CRYPTO_TWOFISH is not set
+# CONFIG_CRYPTO_SERPENT is not set
+# CONFIG_CRYPTO_AES is not set
+# CONFIG_CRYPTO_CAST5 is not set
+# CONFIG_CRYPTO_CAST6 is not set
+# CONFIG_CRYPTO_TEA is not set
+# CONFIG_CRYPTO_ARC4 is not set
+# CONFIG_CRYPTO_KHAZAD is not set
+# CONFIG_CRYPTO_ANUBIS is not set
+# CONFIG_CRYPTO_DEFLATE is not set
+# CONFIG_CRYPTO_MICHAEL_MIC is not set
+# CONFIG_CRYPTO_CRC32C is not set
+# CONFIG_CRYPTO_TEST is not set
+
+#
+# Hardware crypto devices
+#
+
+#
+# SEC2.x Options
+#
+CONFIG_MPC8349E_SEC2x=y
+
+#
+# SEC2.x Test Options
+#
+CONFIG_MPC8349E_SEC2xTEST=y
diff --git a/arch/powerpc/configs/pmac32_defconfig b/arch/powerpc/configs/pmac32_defconfig
index 398203bd98eb..2ace57d1e333 100644
--- a/arch/powerpc/configs/pmac32_defconfig
+++ b/arch/powerpc/configs/pmac32_defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.15-rc5
-# Tue Dec 13 17:24:05 2005
+# Linux kernel version: 2.6.15
+# Sat Jan 14 16:26:08 2006
 #
 # CONFIG_PPC64 is not set
 CONFIG_PPC32=y
@@ -15,11 +15,15 @@ CONFIG_EARLY_PRINTK=y
 CONFIG_GENERIC_NVRAM=y
 CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER=y
 CONFIG_ARCH_MAY_HAVE_PC_FDC=y
+CONFIG_PPC_OF=y
+# CONFIG_PPC_UDBG_16550 is not set
+# CONFIG_CRASH_DUMP is not set
+# CONFIG_GENERIC_TBSYNC is not set
 
 #
 # Processor support
 #
-CONFIG_6xx=y
+CONFIG_CLASSIC32=y
 # CONFIG_PPC_52xx is not set
 # CONFIG_PPC_82xx is not set
 # CONFIG_PPC_83xx is not set
@@ -28,6 +32,7 @@ CONFIG_6xx=y
 # CONFIG_8xx is not set
 # CONFIG_E200 is not set
 # CONFIG_E500 is not set
+CONFIG_6xx=y
 CONFIG_PPC_FPU=y
 CONFIG_ALTIVEC=y
 CONFIG_PPC_STD_MMU=y
@@ -53,17 +58,18 @@ CONFIG_POSIX_MQUEUE=y
 # CONFIG_BSD_PROCESS_ACCT is not set
 CONFIG_SYSCTL=y
 # CONFIG_AUDIT is not set
-CONFIG_HOTPLUG=y
-CONFIG_KOBJECT_UEVENT=y
 CONFIG_IKCONFIG=y
 CONFIG_IKCONFIG_PROC=y
 CONFIG_INITRAMFS_SOURCE=""
+# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 # CONFIG_EMBEDDED is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_ALL is not set
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
+CONFIG_ELF_CORE=y
 CONFIG_BASE_FULL=y
 CONFIG_FUTEX=y
 CONFIG_EPOLL=y
@@ -72,8 +78,10 @@ CONFIG_CC_ALIGN_FUNCTIONS=0
 CONFIG_CC_ALIGN_LABELS=0
 CONFIG_CC_ALIGN_LOOPS=0
 CONFIG_CC_ALIGN_JUMPS=0
+CONFIG_SLAB=y
 # CONFIG_TINY_SHMEM is not set
 CONFIG_BASE_SMALL=0
+# CONFIG_SLOB is not set
 
 #
 # Loadable module support
@@ -113,13 +121,10 @@ CONFIG_PPC_MULTIPLATFORM=y
 # CONFIG_APUS is not set
 # CONFIG_PPC_CHRP is not set
 CONFIG_PPC_PMAC=y
-CONFIG_PPC_OF=y
 CONFIG_MPIC=y
 # CONFIG_PPC_RTAS is not set
 # CONFIG_MMIO_NVRAM is not set
-# CONFIG_CRASH_DUMP is not set
 CONFIG_PPC_MPC106=y
-# CONFIG_GENERIC_TBSYNC is not set
 CONFIG_CPU_FREQ=y
 CONFIG_CPU_FREQ_TABLE=y
 # CONFIG_CPU_FREQ_DEBUG is not set
@@ -195,6 +200,11 @@ CONFIG_CARDBUS=y
 # PC-card bridges
 #
 CONFIG_YENTA=m
+CONFIG_YENTA_O2=y
+CONFIG_YENTA_RICOH=y
+CONFIG_YENTA_TI=y
+CONFIG_YENTA_ENE_TUNE=y
+CONFIG_YENTA_TOSHIBA=y
 # CONFIG_PD6729 is not set
 # CONFIG_I82092 is not set
 CONFIG_PCCARD_NONSTATIC=m
@@ -464,7 +474,7 @@ CONFIG_IEEE80211_CRYPT_TKIP=m
 #
 # CONFIG_STANDALONE is not set
 CONFIG_PREVENT_FIRMWARE_BUILD=y
-CONFIG_FW_LOADER=m
+CONFIG_FW_LOADER=y
 # CONFIG_DEBUG_DRIVER is not set
 
 #
@@ -491,7 +501,7 @@ CONFIG_PROC_EVENTS=y
 # Block devices
 #
 # CONFIG_BLK_DEV_FD is not set
-CONFIG_MAC_FLOPPY=y
+CONFIG_MAC_FLOPPY=m
 # CONFIG_BLK_CPQ_DA is not set
 # CONFIG_BLK_CPQ_CISS_DA is not set
 # CONFIG_BLK_DEV_DAC960 is not set
@@ -603,7 +613,7 @@ CONFIG_SCSI_CONSTANTS=y
 # SCSI Transport Attributes
 #
 CONFIG_SCSI_SPI_ATTRS=y
-# CONFIG_SCSI_FC_ATTRS is not set
+CONFIG_SCSI_FC_ATTRS=y
 # CONFIG_SCSI_ISCSI_ATTRS is not set
 # CONFIG_SCSI_SAS_ATTRS is not set
 
@@ -645,12 +655,7 @@ CONFIG_SCSI_SYM53C8XX_MAX_TAGS=64
 # CONFIG_SCSI_QLOGIC_FC is not set
 # CONFIG_SCSI_QLOGIC_1280 is not set
 CONFIG_SCSI_QLA2XXX=y
-# CONFIG_SCSI_QLA21XX is not set
-# CONFIG_SCSI_QLA22XX is not set
-# CONFIG_SCSI_QLA2300 is not set
-# CONFIG_SCSI_QLA2322 is not set
-# CONFIG_SCSI_QLA6312 is not set
-# CONFIG_SCSI_QLA24XX is not set
+# CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE is not set
 # CONFIG_SCSI_LPFC is not set
 # CONFIG_SCSI_DC395x is not set
 # CONFIG_SCSI_DC390T is not set
@@ -658,7 +663,7 @@ CONFIG_SCSI_QLA2XXX=y
 # CONFIG_SCSI_DEBUG is not set
 CONFIG_SCSI_MESH=y
 CONFIG_SCSI_MESH_SYNC_RATE=5
-CONFIG_SCSI_MESH_RESET_DELAY_MS=1000
+CONFIG_SCSI_MESH_RESET_DELAY_MS=4000
 CONFIG_SCSI_MAC53C94=y
 
 #
@@ -727,7 +732,6 @@ CONFIG_IEEE1394_SBP2=m
 CONFIG_IEEE1394_ETH1394=m
 CONFIG_IEEE1394_DV1394=m
 CONFIG_IEEE1394_RAWIO=m
-# CONFIG_IEEE1394_CMP is not set
 
 #
 # I2O device support
@@ -740,7 +744,7 @@ CONFIG_IEEE1394_RAWIO=m
 CONFIG_ADB=y
 CONFIG_ADB_CUDA=y
 CONFIG_ADB_PMU=y
-CONFIG_PMAC_APM_EMU=y
+CONFIG_PMAC_APM_EMU=m
 CONFIG_PMAC_MEDIABAY=y
 CONFIG_PMAC_BACKLIGHT=y
 CONFIG_INPUT_ADBHID=y
@@ -819,6 +823,7 @@ CONFIG_PCNET32=y
 # CONFIG_R8169 is not set
 # CONFIG_SIS190 is not set
 # CONFIG_SKGE is not set
+# CONFIG_SKY2 is not set
 # CONFIG_SK98LIN is not set
 # CONFIG_VIA_VELOCITY is not set
 # CONFIG_TIGON3 is not set
@@ -978,14 +983,14 @@ CONFIG_HW_CONSOLE=y
 CONFIG_SERIAL_8250=m
 # CONFIG_SERIAL_8250_CS is not set
 CONFIG_SERIAL_8250_NR_UARTS=4
+CONFIG_SERIAL_8250_RUNTIME_UARTS=4
 # CONFIG_SERIAL_8250_EXTENDED is not set
 
 #
 # Non-8250 serial port support
 #
 CONFIG_SERIAL_CORE=m
-# CONFIG_SERIAL_PMACZILOG is not set
-# CONFIG_SERIAL_JSM is not set
+CONFIG_SERIAL_PMACZILOG=m
 CONFIG_UNIX98_PTYS=y
 CONFIG_LEGACY_PTYS=y
 CONFIG_LEGACY_PTY_COUNT=256
@@ -1058,7 +1063,7 @@ CONFIG_I2C_ALGOBIT=y
 # CONFIG_I2C_I801 is not set
 # CONFIG_I2C_I810 is not set
 # CONFIG_I2C_PIIX4 is not set
-CONFIG_I2C_KEYWEST=m
+CONFIG_I2C_POWERMAC=y
 # CONFIG_I2C_MPC is not set
 # CONFIG_I2C_NFORCE2 is not set
 # CONFIG_I2C_PARPORT_LIGHT is not set
@@ -1160,7 +1165,6 @@ CONFIG_FB_ATY128=y
 CONFIG_FB_ATY=y
 CONFIG_FB_ATY_CT=y
 # CONFIG_FB_ATY_GENERIC_LCD is not set
-# CONFIG_FB_ATY_XL_INIT is not set
 CONFIG_FB_ATY_GX=y
 # CONFIG_FB_SAVAGE is not set
 # CONFIG_FB_SIS is not set
@@ -1169,7 +1173,6 @@ CONFIG_FB_ATY_GX=y
 CONFIG_FB_3DFX=y
 # CONFIG_FB_3DFX_ACCEL is not set
 # CONFIG_FB_VOODOO1 is not set
-# CONFIG_FB_CYBLA is not set
 # CONFIG_FB_TRIDENT is not set
 # CONFIG_FB_VIRTUAL is not set
 
@@ -1214,9 +1217,10 @@ CONFIG_SND_OSSEMUL=y
 CONFIG_SND_MIXER_OSS=m
 CONFIG_SND_PCM_OSS=m
 CONFIG_SND_SEQUENCER_OSS=y
+# CONFIG_SND_DYNAMIC_MINORS is not set
+CONFIG_SND_SUPPORT_OLD_API=y
 # CONFIG_SND_VERBOSE_PRINTK is not set
 # CONFIG_SND_DEBUG is not set
-CONFIG_SND_GENERIC_DRIVER=y
 
 #
 # Generic devices
@@ -1230,6 +1234,8 @@ CONFIG_SND_DUMMY=m
 #
 # PCI devices
 #
+# CONFIG_SND_AD1889 is not set
+# CONFIG_SND_ALS4000 is not set
 # CONFIG_SND_ALI5451 is not set
 # CONFIG_SND_ATIIXP is not set
 # CONFIG_SND_ATIIXP_MODEM is not set
@@ -1238,45 +1244,44 @@ CONFIG_SND_DUMMY=m
 # CONFIG_SND_AU8830 is not set
 # CONFIG_SND_AZT3328 is not set
 # CONFIG_SND_BT87X is not set
-# CONFIG_SND_CS46XX is not set
+# CONFIG_SND_CA0106 is not set
+# CONFIG_SND_CMIPCI is not set
 # CONFIG_SND_CS4281 is not set
+# CONFIG_SND_CS46XX is not set
 # CONFIG_SND_EMU10K1 is not set
 # CONFIG_SND_EMU10K1X is not set
-# CONFIG_SND_CA0106 is not set
-# CONFIG_SND_KORG1212 is not set
-# CONFIG_SND_MIXART is not set
-# CONFIG_SND_NM256 is not set
-# CONFIG_SND_RME32 is not set
-# CONFIG_SND_RME96 is not set
-# CONFIG_SND_RME9652 is not set
-# CONFIG_SND_HDSP is not set
-# CONFIG_SND_HDSPM is not set
-# CONFIG_SND_TRIDENT is not set
-# CONFIG_SND_YMFPCI is not set
-# CONFIG_SND_AD1889 is not set
-# CONFIG_SND_ALS4000 is not set
-# CONFIG_SND_CMIPCI is not set
 # CONFIG_SND_ENS1370 is not set
 # CONFIG_SND_ENS1371 is not set
 # CONFIG_SND_ES1938 is not set
 # CONFIG_SND_ES1968 is not set
-# CONFIG_SND_MAESTRO3 is not set
 # CONFIG_SND_FM801 is not set
+# CONFIG_SND_HDA_INTEL is not set
+# CONFIG_SND_HDSP is not set
+# CONFIG_SND_HDSPM is not set
 # CONFIG_SND_ICE1712 is not set
 # CONFIG_SND_ICE1724 is not set
 # CONFIG_SND_INTEL8X0 is not set
 # CONFIG_SND_INTEL8X0M is not set
+# CONFIG_SND_KORG1212 is not set
+# CONFIG_SND_MAESTRO3 is not set
+# CONFIG_SND_MIXART is not set
+# CONFIG_SND_NM256 is not set
+# CONFIG_SND_PCXHR is not set
+# CONFIG_SND_RME32 is not set
+# CONFIG_SND_RME96 is not set
+# CONFIG_SND_RME9652 is not set
 # CONFIG_SND_SONICVIBES is not set
+# CONFIG_SND_TRIDENT is not set
 # CONFIG_SND_VIA82XX is not set
 # CONFIG_SND_VIA82XX_MODEM is not set
 # CONFIG_SND_VX222 is not set
-# CONFIG_SND_HDA_INTEL is not set
+# CONFIG_SND_YMFPCI is not set
 
 #
 # ALSA PowerMac devices
 #
 CONFIG_SND_POWERMAC=m
-# CONFIG_SND_POWERMAC_AUTO_DRC is not set
+CONFIG_SND_POWERMAC_AUTO_DRC=y
 
 #
 # USB devices
@@ -1336,6 +1341,7 @@ CONFIG_USB_PRINTER=m
 # may also be needed; see USB_STORAGE Help for more information
 #
 # CONFIG_USB_STORAGE is not set
+# CONFIG_USB_LIBUSUAL is not set
 
 #
 # USB Input Devices
@@ -1355,6 +1361,7 @@ CONFIG_USB_HIDINPUT=y
 # CONFIG_USB_YEALINK is not set
 # CONFIG_USB_XPAD is not set
 # CONFIG_USB_ATI_REMOTE is not set
+# CONFIG_USB_ATI_REMOTE2 is not set
 # CONFIG_USB_KEYSPAN_REMOTE is not set
 CONFIG_USB_APPLETOUCH=y
 
@@ -1501,6 +1508,7 @@ CONFIG_FS_MBCACHE=y
 # CONFIG_JFS_FS is not set
 # CONFIG_FS_POSIX_ACL is not set
 # CONFIG_XFS_FS is not set
+# CONFIG_OCFS2_FS is not set
 # CONFIG_MINIX_FS is not set
 # CONFIG_ROMFS_FS is not set
 CONFIG_INOTIFY=y
@@ -1540,6 +1548,7 @@ CONFIG_TMPFS=y
 # CONFIG_HUGETLB_PAGE is not set
 CONFIG_RAMFS=y
 CONFIG_RELAYFS_FS=m
+# CONFIG_CONFIGFS_FS is not set
 
 #
 # Miscellaneous filesystems
@@ -1670,12 +1679,13 @@ CONFIG_OPROFILE=y
 # Kernel hacking
 #
 # CONFIG_PRINTK_TIME is not set
-CONFIG_DEBUG_KERNEL=y
 # CONFIG_MAGIC_SYSRQ is not set
+CONFIG_DEBUG_KERNEL=y
 CONFIG_LOG_BUF_SHIFT=14
 CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_DEBUG_SLAB is not set
+# CONFIG_DEBUG_MUTEXES is not set
 # CONFIG_DEBUG_SPINLOCK is not set
 # CONFIG_DEBUG_SPINLOCK_SLEEP is not set
 # CONFIG_DEBUG_KOBJECT is not set
@@ -1688,6 +1698,11 @@ CONFIG_XMON=y
 CONFIG_XMON_DEFAULT=y
 # CONFIG_BDI_SWITCH is not set
 CONFIG_BOOTX_TEXT=y
+# CONFIG_PPC_EARLY_DEBUG_LPAR is not set
+# CONFIG_PPC_EARLY_DEBUG_G5 is not set
+# CONFIG_PPC_EARLY_DEBUG_RTAS is not set
+# CONFIG_PPC_EARLY_DEBUG_MAPLE is not set
+# CONFIG_PPC_EARLY_DEBUG_ISERIES is not set
 
 #
 # Security options
diff --git a/arch/powerpc/kernel/Makefile b/arch/powerpc/kernel/Makefile
index a94699d8dc52..c287980b7e65 100644
--- a/arch/powerpc/kernel/Makefile
+++ b/arch/powerpc/kernel/Makefile
@@ -60,7 +60,8 @@ obj-$(CONFIG_MODULES)		+= $(module-y)
 
 pci64-$(CONFIG_PPC64)           += pci_64.o pci_dn.o pci_iommu.o \
                                    pci_direct_iommu.o iomap.o
-obj-$(CONFIG_PCI)               += $(pci64-y)
+pci32-$(CONFIG_PPC32)           := pci_32.o
+obj-$(CONFIG_PCI)               += $(pci64-y) $(pci32-y)
 kexec-$(CONFIG_PPC64)           := machine_kexec_64.o crash.o
 kexec-$(CONFIG_PPC32)           := machine_kexec_32.o
 obj-$(CONFIG_KEXEC)             += machine_kexec.o $(kexec-y)
diff --git a/arch/powerpc/kernel/asm-offsets.c b/arch/powerpc/kernel/asm-offsets.c
index 56399c5c931a..840aad43a98b 100644
--- a/arch/powerpc/kernel/asm-offsets.c
+++ b/arch/powerpc/kernel/asm-offsets.c
@@ -135,7 +135,7 @@ int main(void)
         DEFINE(PACA_EXMC, offsetof(struct paca_struct, exmc));
         DEFINE(PACA_EXSLB, offsetof(struct paca_struct, exslb));
         DEFINE(PACAEMERGSP, offsetof(struct paca_struct, emergency_sp));
-        DEFINE(PACALPPACA, offsetof(struct paca_struct, lppaca));
+        DEFINE(PACALPPACAPTR, offsetof(struct paca_struct, lppaca_ptr));
         DEFINE(PACAHWCPUID, offsetof(struct paca_struct, hw_cpu_id));
 
         DEFINE(LPPACASRR0, offsetof(struct lppaca, saved_srr0));
diff --git a/arch/powerpc/kernel/cpu_setup_power4.S b/arch/powerpc/kernel/cpu_setup_power4.S
index cca942fe6115..b61d86e7ceb6 100644
--- a/arch/powerpc/kernel/cpu_setup_power4.S
+++ b/arch/powerpc/kernel/cpu_setup_power4.S
@@ -130,7 +130,7 @@ _GLOBAL(__save_cpu_setup)
         mfcr    r7
 
         /* Get storage ptr */
-        LOADADDR(r5,cpu_state_storage)
+        LOAD_REG_IMMEDIATE(r5,cpu_state_storage)
 
         /* We only deal with 970 for now */
         mfspr   r0,SPRN_PVR
@@ -164,7 +164,7 @@ _GLOBAL(__restore_cpu_setup)
         /* Get storage ptr (FIXME when using anton reloc as we
          * are running with translation disabled here
          */
-        LOADADDR(r5,cpu_state_storage)
+        LOAD_REG_IMMEDIATE(r5,cpu_state_storage)
 
         /* We only deal with 970 for now */
         mfspr   r0,SPRN_PVR
diff --git a/arch/powerpc/kernel/cputable.c b/arch/powerpc/kernel/cputable.c
index 43c74a6b07b1..10696456a4c6 100644
--- a/arch/powerpc/kernel/cputable.c
+++ b/arch/powerpc/kernel/cputable.c
@@ -55,7 +55,8 @@ extern void __setup_cpu_ppc970(unsigned long offset, struct cpu_spec* spec);
 #define COMMON_USER_POWER4      (COMMON_USER_PPC64 | PPC_FEATURE_POWER4)
 #define COMMON_USER_POWER5      (COMMON_USER_PPC64 | PPC_FEATURE_POWER5)
 #define COMMON_USER_POWER5_PLUS (COMMON_USER_PPC64 | PPC_FEATURE_POWER5_PLUS)
-
+#define COMMON_USER_BOOKE       (PPC_FEATURE_32 | PPC_FEATURE_HAS_MMU | \
+                                 PPC_FEATURE_BOOKE)
 
 /* We only set the spe features if the kernel was compiled with
  * spe support
@@ -79,7 +80,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 8,
                 .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/power3",
-                .oprofile_type          = RS64,
+                .oprofile_type          = PPC_OPROFILE_RS64,
+                .platform               = "power3",
         },
         {       /* Power3+ */
                 .pvr_mask               = 0xffff0000,
@@ -92,7 +94,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 8,
                 .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/power3",
-                .oprofile_type          = RS64,
+                .oprofile_type          = PPC_OPROFILE_RS64,
+                .platform               = "power3",
         },
         {       /* Northstar */
                 .pvr_mask               = 0xffff0000,
@@ -105,7 +108,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 8,
                 .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/rs64",
-                .oprofile_type          = RS64,
+                .oprofile_type          = PPC_OPROFILE_RS64,
+                .platform               = "rs64",
         },
         {       /* Pulsar */
                 .pvr_mask               = 0xffff0000,
@@ -118,7 +122,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 8,
                 .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/rs64",
-                .oprofile_type          = RS64,
+                .oprofile_type          = PPC_OPROFILE_RS64,
+                .platform               = "rs64",
         },
         {       /* I-star */
                 .pvr_mask               = 0xffff0000,
@@ -131,7 +136,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 8,
                 .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/rs64",
-                .oprofile_type          = RS64,
+                .oprofile_type          = PPC_OPROFILE_RS64,
+                .platform               = "rs64",
         },
         {       /* S-star */
                 .pvr_mask               = 0xffff0000,
@@ -144,7 +150,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 8,
                 .cpu_setup              = __setup_cpu_power3,
                 .oprofile_cpu_type      = "ppc64/rs64",
-                .oprofile_type          = RS64,
+                .oprofile_type          = PPC_OPROFILE_RS64,
+                .platform               = "rs64",
         },
         {       /* Power4 */
                 .pvr_mask               = 0xffff0000,
@@ -157,7 +164,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 8,
                 .cpu_setup              = __setup_cpu_power4,
                 .oprofile_cpu_type      = "ppc64/power4",
-                .oprofile_type          = POWER4,
+                .oprofile_type          = PPC_OPROFILE_POWER4,
+                .platform               = "power4",
         },
         {       /* Power4+ */
                 .pvr_mask               = 0xffff0000,
@@ -170,7 +178,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 8,
                 .cpu_setup              = __setup_cpu_power4,
                 .oprofile_cpu_type      = "ppc64/power4",
-                .oprofile_type          = POWER4,
+                .oprofile_type          = PPC_OPROFILE_POWER4,
+                .platform               = "power4",
         },
         {       /* PPC970 */
                 .pvr_mask               = 0xffff0000,
@@ -184,7 +193,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 8,
                 .cpu_setup              = __setup_cpu_ppc970,
                 .oprofile_cpu_type      = "ppc64/970",
-                .oprofile_type          = POWER4,
+                .oprofile_type          = PPC_OPROFILE_POWER4,
+                .platform               = "ppc970",
         },
 #endif /* CONFIG_PPC64 */
 #if defined(CONFIG_PPC64) || defined(CONFIG_POWER4)
@@ -204,7 +214,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 8,
                 .cpu_setup              = __setup_cpu_ppc970,
                 .oprofile_cpu_type      = "ppc64/970",
-                .oprofile_type          = POWER4,
+                .oprofile_type          = PPC_OPROFILE_POWER4,
+                .platform               = "ppc970",
         },
 #endif /* defined(CONFIG_PPC64) || defined(CONFIG_POWER4) */
 #ifdef CONFIG_PPC64
@@ -219,7 +230,8 @@ struct cpu_spec	cpu_specs[] = {
                 .dcache_bsize           = 128,
                 .cpu_setup              = __setup_cpu_ppc970,
                 .oprofile_cpu_type      = "ppc64/970",
-                .oprofile_type          = POWER4,
+                .oprofile_type          = PPC_OPROFILE_POWER4,
+                .platform               = "ppc970",
         },
         {       /* Power5 GR */
                 .pvr_mask               = 0xffff0000,
@@ -232,7 +244,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 6,
                 .cpu_setup              = __setup_cpu_power4,
                 .oprofile_cpu_type      = "ppc64/power5",
-                .oprofile_type          = POWER4,
+                .oprofile_type          = PPC_OPROFILE_POWER4,
+                .platform               = "power5",
         },
         {       /* Power5 GS */
                 .pvr_mask               = 0xffff0000,
@@ -245,7 +258,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 6,
                 .cpu_setup              = __setup_cpu_power4,
                 .oprofile_cpu_type      = "ppc64/power5+",
-                .oprofile_type          = POWER4,
+                .oprofile_type          = PPC_OPROFILE_POWER4,
+                .platform               = "power5+",
         },
         {       /* Cell Broadband Engine */
                 .pvr_mask               = 0xffff0000,
@@ -257,6 +271,7 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 128,
                 .dcache_bsize           = 128,
                 .cpu_setup              = __setup_cpu_be,
+                .platform               = "ppc-cell-be",
         },
         {       /* default match */
                 .pvr_mask               = 0x00000000,
@@ -268,6 +283,7 @@ struct cpu_spec	cpu_specs[] = {
                 .dcache_bsize           = 128,
                 .num_pmcs               = 6,
                 .cpu_setup              = __setup_cpu_power4,
+                .platform               = "power4",
         }
 #endif  /* CONFIG_PPC64 */
 #ifdef CONFIG_PPC32
@@ -281,6 +297,7 @@ struct cpu_spec	cpu_specs[] = {
                         PPC_FEATURE_UNIFIED_CACHE | PPC_FEATURE_NO_TB,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc601",
         },
         {       /* 603 */
                 .pvr_mask               = 0xffff0000,
@@ -290,7 +307,8 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_user_features      = COMMON_USER,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
-                .cpu_setup              = __setup_cpu_603
+                .cpu_setup              = __setup_cpu_603,
+                .platform               = "ppc603",
         },
         {       /* 603e */
                 .pvr_mask               = 0xffff0000,
@@ -300,7 +318,8 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_user_features      = COMMON_USER,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
-                .cpu_setup              = __setup_cpu_603
+                .cpu_setup              = __setup_cpu_603,
+                .platform               = "ppc603",
         },
         {       /* 603ev */
                 .pvr_mask               = 0xffff0000,
@@ -310,7 +329,8 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_user_features      = COMMON_USER,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
-                .cpu_setup              = __setup_cpu_603
+                .cpu_setup              = __setup_cpu_603,
+                .platform               = "ppc603",
         },
         {       /* 604 */
                 .pvr_mask               = 0xffff0000,
@@ -321,7 +341,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 2,
-                .cpu_setup              = __setup_cpu_604
+                .cpu_setup              = __setup_cpu_604,
+                .platform               = "ppc604",
         },
         {       /* 604e */
                 .pvr_mask               = 0xfffff000,
@@ -332,7 +353,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
-                .cpu_setup              = __setup_cpu_604
+                .cpu_setup              = __setup_cpu_604,
+                .platform               = "ppc604",
         },
         {       /* 604r */
                 .pvr_mask               = 0xffff0000,
@@ -343,7 +365,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
-                .cpu_setup              = __setup_cpu_604
+                .cpu_setup              = __setup_cpu_604,
+                .platform               = "ppc604",
         },
         {       /* 604ev */
                 .pvr_mask               = 0xffff0000,
@@ -354,7 +377,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
-                .cpu_setup              = __setup_cpu_604
+                .cpu_setup              = __setup_cpu_604,
+                .platform               = "ppc604",
         },
         {       /* 740/750 (0x4202, don't support TAU ?) */
                 .pvr_mask               = 0xffffffff,
@@ -365,7 +389,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
-                .cpu_setup              = __setup_cpu_750
+                .cpu_setup              = __setup_cpu_750,
+                .platform               = "ppc750",
         },
         {       /* 750CX (80100 and 8010x?) */
                 .pvr_mask               = 0xfffffff0,
@@ -376,7 +401,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
-                .cpu_setup              = __setup_cpu_750cx
+                .cpu_setup              = __setup_cpu_750cx,
+                .platform               = "ppc750",
         },
         {       /* 750CX (82201 and 82202) */
                 .pvr_mask               = 0xfffffff0,
@@ -387,7 +413,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
-                .cpu_setup              = __setup_cpu_750cx
+                .cpu_setup              = __setup_cpu_750cx,
+                .platform               = "ppc750",
         },
         {       /* 750CXe (82214) */
                 .pvr_mask               = 0xfffffff0,
@@ -398,7 +425,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
-                .cpu_setup              = __setup_cpu_750cx
+                .cpu_setup              = __setup_cpu_750cx,
+                .platform               = "ppc750",
         },
         {       /* 750CXe "Gekko" (83214) */
                 .pvr_mask               = 0xffffffff,
@@ -409,7 +437,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
-                .cpu_setup              = __setup_cpu_750cx
+                .cpu_setup              = __setup_cpu_750cx,
+                .platform               = "ppc750",
         },
         {       /* 745/755 */
                 .pvr_mask               = 0xfffff000,
@@ -420,7 +449,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
-                .cpu_setup              = __setup_cpu_750
+                .cpu_setup              = __setup_cpu_750,
+                .platform               = "ppc750",
         },
         {       /* 750FX rev 1.x */
                 .pvr_mask               = 0xffffff00,
@@ -431,7 +461,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
-                .cpu_setup              = __setup_cpu_750
+                .cpu_setup              = __setup_cpu_750,
+                .platform               = "ppc750",
         },
         {       /* 750FX rev 2.0 must disable HID0[DPM] */
                 .pvr_mask               = 0xffffffff,
@@ -442,7 +473,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
-                .cpu_setup              = __setup_cpu_750
+                .cpu_setup              = __setup_cpu_750,
+                .platform               = "ppc750",
         },
         {       /* 750FX (All revs except 2.0) */
                 .pvr_mask               = 0xffff0000,
@@ -453,7 +485,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
-                .cpu_setup              = __setup_cpu_750fx
+                .cpu_setup              = __setup_cpu_750fx,
+                .platform               = "ppc750",
         },
         {       /* 750GX */
                 .pvr_mask               = 0xffff0000,
@@ -464,7 +497,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
-                .cpu_setup              = __setup_cpu_750fx
+                .cpu_setup              = __setup_cpu_750fx,
+                .platform               = "ppc750",
         },
         {       /* 740/750 (L2CR bit need fixup for 740) */
                 .pvr_mask               = 0xffff0000,
@@ -475,7 +509,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
-                .cpu_setup              = __setup_cpu_750
+                .cpu_setup              = __setup_cpu_750,
+                .platform               = "ppc750",
         },
         {       /* 7400 rev 1.1 ? (no TAU) */
                 .pvr_mask               = 0xffffffff,
@@ -486,7 +521,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
-                .cpu_setup              = __setup_cpu_7400
+                .cpu_setup              = __setup_cpu_7400,
+                .platform               = "ppc7400",
         },
         {       /* 7400 */
                 .pvr_mask               = 0xffff0000,
@@ -497,7 +533,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
-                .cpu_setup              = __setup_cpu_7400
+                .cpu_setup              = __setup_cpu_7400,
+                .platform               = "ppc7400",
         },
         {       /* 7410 */
                 .pvr_mask               = 0xffff0000,
@@ -508,7 +545,8 @@ struct cpu_spec	cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
-                .cpu_setup              = __setup_cpu_7410
+                .cpu_setup              = __setup_cpu_7410,
+                .platform               = "ppc7400",
         },
         {       /* 7450 2.0 - no doze/nap */
                 .pvr_mask               = 0xffffffff,
@@ -521,7 +559,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 6,
                 .cpu_setup              = __setup_cpu_745x,
                 .oprofile_cpu_type      = "ppc/7450",
-                .oprofile_type          = G4,
+                .oprofile_type          = PPC_OPROFILE_G4,
+                .platform               = "ppc7450",
         },
         {       /* 7450 2.1 */
                 .pvr_mask               = 0xffffffff,
@@ -534,7 +573,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 6,
                 .cpu_setup              = __setup_cpu_745x,
                 .oprofile_cpu_type      = "ppc/7450",
-                .oprofile_type          = G4,
+                .oprofile_type          = PPC_OPROFILE_G4,
+                .platform               = "ppc7450",
         },
         {       /* 7450 2.3 and newer */
                 .pvr_mask               = 0xffff0000,
@@ -547,7 +587,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 6,
                 .cpu_setup              = __setup_cpu_745x,
                 .oprofile_cpu_type      = "ppc/7450",
-                .oprofile_type          = G4,
+                .oprofile_type          = PPC_OPROFILE_G4,
+                .platform               = "ppc7450",
         },
         {       /* 7455 rev 1.x */
                 .pvr_mask               = 0xffffff00,
@@ -560,7 +601,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 6,
                 .cpu_setup              = __setup_cpu_745x,
                 .oprofile_cpu_type      = "ppc/7450",
-                .oprofile_type          = G4,
+                .oprofile_type          = PPC_OPROFILE_G4,
+                .platform               = "ppc7450",
         },
         {       /* 7455 rev 2.0 */
                 .pvr_mask               = 0xffffffff,
@@ -573,7 +615,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 6,
                 .cpu_setup              = __setup_cpu_745x,
                 .oprofile_cpu_type      = "ppc/7450",
-                .oprofile_type          = G4,
+                .oprofile_type          = PPC_OPROFILE_G4,
+                .platform               = "ppc7450",
         },
         {       /* 7455 others */
                 .pvr_mask               = 0xffff0000,
@@ -586,7 +629,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 6,
                 .cpu_setup              = __setup_cpu_745x,
                 .oprofile_cpu_type      = "ppc/7450",
-                .oprofile_type          = G4,
+                .oprofile_type          = PPC_OPROFILE_G4,
+                .platform               = "ppc7450",
         },
         {       /* 7447/7457 Rev 1.0 */
                 .pvr_mask               = 0xffffffff,
@@ -599,7 +643,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 6,
                 .cpu_setup              = __setup_cpu_745x,
                 .oprofile_cpu_type      = "ppc/7450",
-                .oprofile_type          = G4,
+                .oprofile_type          = PPC_OPROFILE_G4,
+                .platform               = "ppc7450",
         },
         {       /* 7447/7457 Rev 1.1 */
                 .pvr_mask               = 0xffffffff,
@@ -612,7 +657,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 6,
                 .cpu_setup              = __setup_cpu_745x,
                 .oprofile_cpu_type      = "ppc/7450",
-                .oprofile_type          = G4,
+                .oprofile_type          = PPC_OPROFILE_G4,
+                .platform               = "ppc7450",
         },
         {       /* 7447/7457 Rev 1.2 and later */
                 .pvr_mask               = 0xffff0000,
@@ -625,7 +671,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 6,
                 .cpu_setup              = __setup_cpu_745x,
                 .oprofile_cpu_type      = "ppc/7450",
-                .oprofile_type          = G4,
+                .oprofile_type          = PPC_OPROFILE_G4,
+                .platform               = "ppc7450",
         },
         {       /* 7447A */
                 .pvr_mask               = 0xffff0000,
@@ -638,7 +685,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 6,
                 .cpu_setup              = __setup_cpu_745x,
                 .oprofile_cpu_type      = "ppc/7450",
-                .oprofile_type          = G4,
+                .oprofile_type          = PPC_OPROFILE_G4,
+                .platform               = "ppc7450",
         },
         {       /* 7448 */
                 .pvr_mask               = 0xffff0000,
@@ -651,7 +699,8 @@ struct cpu_spec	cpu_specs[] = {
                 .num_pmcs               = 6,
                 .cpu_setup              = __setup_cpu_745x,
                 .oprofile_cpu_type      = "ppc/7450",
-                .oprofile_type          = G4,
+                .oprofile_type          = PPC_OPROFILE_G4,
+                .platform               = "ppc7450",
         },
         {       /* 82xx (8240, 8245, 8260 are all 603e cores) */
                 .pvr_mask               = 0x7fff0000,
@@ -661,7 +710,8 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_user_features      = COMMON_USER,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
-                .cpu_setup              = __setup_cpu_603
+                .cpu_setup              = __setup_cpu_603,
+                .platform               = "ppc603",
         },
         {       /* All G2_LE (603e core, plus some) have the same pvr */
                 .pvr_mask               = 0x7fff0000,
@@ -671,7 +721,8 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_user_features      = COMMON_USER,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
-                .cpu_setup              = __setup_cpu_603
+                .cpu_setup              = __setup_cpu_603,
+                .platform               = "ppc603",
         },
         {       /* e300 (a 603e core, plus some) on 83xx */
                 .pvr_mask               = 0x7fff0000,
@@ -681,7 +732,8 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_user_features      = COMMON_USER,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
-                .cpu_setup              = __setup_cpu_603
+                .cpu_setup              = __setup_cpu_603,
+                .platform               = "ppc603",
         },
         {       /* default match, we assume split I/D cache & TB (non-601)... */
                 .pvr_mask               = 0x00000000,
@@ -691,6 +743,7 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_user_features      = COMMON_USER,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc603",
         },
 #endif /* CLASSIC_PPC */
 #ifdef CONFIG_8xx
@@ -704,6 +757,7 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_user_features      = PPC_FEATURE_32 | PPC_FEATURE_HAS_MMU,
                 .icache_bsize           = 16,
                 .dcache_bsize           = 16,
+                .platform               = "ppc823",
         },
 #endif /* CONFIG_8xx */
 #ifdef CONFIG_40x
@@ -715,6 +769,7 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_user_features      = PPC_FEATURE_32 | PPC_FEATURE_HAS_MMU,
                 .icache_bsize           = 16,
                 .dcache_bsize           = 16,
+                .platform               = "ppc403",
         },
         {       /* 403GCX */
                 .pvr_mask               = 0xffffff00,
@@ -725,6 +780,7 @@ struct cpu_spec	cpu_specs[] = {
                         PPC_FEATURE_HAS_MMU | PPC_FEATURE_NO_TB,
                 .icache_bsize           = 16,
                 .dcache_bsize           = 16,
+                .platform               = "ppc403",
         },
         {       /* 403G ?? */
                 .pvr_mask               = 0xffff0000,
@@ -734,6 +790,7 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_user_features      = PPC_FEATURE_32 | PPC_FEATURE_HAS_MMU,
                 .icache_bsize           = 16,
                 .dcache_bsize           = 16,
+                .platform               = "ppc403",
         },
         {       /* 405GP */
                 .pvr_mask               = 0xffff0000,
@@ -744,6 +801,7 @@ struct cpu_spec	cpu_specs[] = {
                         PPC_FEATURE_HAS_MMU | PPC_FEATURE_HAS_4xxMAC,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc405",
         },
         {       /* STB 03xxx */
                 .pvr_mask               = 0xffff0000,
@@ -754,6 +812,7 @@ struct cpu_spec	cpu_specs[] = {
                         PPC_FEATURE_HAS_MMU | PPC_FEATURE_HAS_4xxMAC,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc405",
         },
         {       /* STB 04xxx */
                 .pvr_mask               = 0xffff0000,
@@ -764,6 +823,7 @@ struct cpu_spec	cpu_specs[] = {
                         PPC_FEATURE_HAS_MMU | PPC_FEATURE_HAS_4xxMAC,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc405",
         },
         {       /* NP405L */
                 .pvr_mask               = 0xffff0000,
@@ -774,6 +834,7 @@ struct cpu_spec	cpu_specs[] = {
                         PPC_FEATURE_HAS_MMU | PPC_FEATURE_HAS_4xxMAC,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc405",
         },
         {       /* NP4GS3 */
                 .pvr_mask               = 0xffff0000,
@@ -784,6 +845,7 @@ struct cpu_spec	cpu_specs[] = {
                         PPC_FEATURE_HAS_MMU | PPC_FEATURE_HAS_4xxMAC,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc405",
         },
         {   /* NP405H */
                 .pvr_mask               = 0xffff0000,
@@ -794,6 +856,7 @@ struct cpu_spec	cpu_specs[] = {
                         PPC_FEATURE_HAS_MMU | PPC_FEATURE_HAS_4xxMAC,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc405",
         },
         {       /* 405GPr */
                 .pvr_mask               = 0xffff0000,
@@ -804,6 +867,7 @@ struct cpu_spec	cpu_specs[] = {
                         PPC_FEATURE_HAS_MMU | PPC_FEATURE_HAS_4xxMAC,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc405",
         },
         {   /* STBx25xx */
                 .pvr_mask               = 0xffff0000,
@@ -814,6 +878,7 @@ struct cpu_spec	cpu_specs[] = {
                         PPC_FEATURE_HAS_MMU | PPC_FEATURE_HAS_4xxMAC,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc405",
         },
         {       /* 405LP */
                 .pvr_mask               = 0xffff0000,
@@ -823,6 +888,7 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_user_features      = PPC_FEATURE_32 | PPC_FEATURE_HAS_MMU,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc405",
         },
         {       /* Xilinx Virtex-II Pro  */
                 .pvr_mask               = 0xffff0000,
@@ -833,6 +899,7 @@ struct cpu_spec	cpu_specs[] = {
                         PPC_FEATURE_HAS_MMU | PPC_FEATURE_HAS_4xxMAC,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc405",
         },
         {       /* 405EP */
                 .pvr_mask               = 0xffff0000,
@@ -843,6 +910,7 @@ struct cpu_spec	cpu_specs[] = {
                         PPC_FEATURE_HAS_MMU | PPC_FEATURE_HAS_4xxMAC,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc405",
         },
 
 #endif /* CONFIG_40x */
@@ -852,81 +920,90 @@ struct cpu_spec	cpu_specs[] = {
                 .pvr_value              = 0x40000850,
                 .cpu_name               = "440EP Rev. A",
                 .cpu_features           = CPU_FTRS_44X,
-                .cpu_user_features      = COMMON_USER, /* 440EP has an FPU */
+                .cpu_user_features      = COMMON_USER_BOOKE | PPC_FEATURE_HAS_FPU,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc440",
         },
         {
                 .pvr_mask               = 0xf0000fff,
                 .pvr_value              = 0x400008d3,
                 .cpu_name               = "440EP Rev. B",
                 .cpu_features           = CPU_FTRS_44X,
-                .cpu_user_features      = COMMON_USER, /* 440EP has an FPU */
+                .cpu_user_features      = COMMON_USER_BOOKE | PPC_FEATURE_HAS_FPU,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc440",
         },
         {       /* 440GP Rev. B */
                 .pvr_mask               = 0xf0000fff,
                 .pvr_value              = 0x40000440,
                 .cpu_name               = "440GP Rev. B",
                 .cpu_features           = CPU_FTRS_44X,
-                .cpu_user_features      = PPC_FEATURE_32 | PPC_FEATURE_HAS_MMU,
+                .cpu_user_features      = COMMON_USER_BOOKE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc440gp",
         },
         {       /* 440GP Rev. C */
                 .pvr_mask               = 0xf0000fff,
                 .pvr_value              = 0x40000481,
                 .cpu_name               = "440GP Rev. C",
                 .cpu_features           = CPU_FTRS_44X,
-                .cpu_user_features      = PPC_FEATURE_32 | PPC_FEATURE_HAS_MMU,
+                .cpu_user_features      = COMMON_USER_BOOKE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc440gp",
         },
         { /* 440GX Rev. A */
                 .pvr_mask               = 0xf0000fff,
                 .pvr_value              = 0x50000850,
                 .cpu_name               = "440GX Rev. A",
                 .cpu_features           = CPU_FTRS_44X,
-                .cpu_user_features      = PPC_FEATURE_32 | PPC_FEATURE_HAS_MMU,
+                .cpu_user_features      = COMMON_USER_BOOKE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc440",
         },
         { /* 440GX Rev. B */
                 .pvr_mask               = 0xf0000fff,
                 .pvr_value              = 0x50000851,
                 .cpu_name               = "440GX Rev. B",
                 .cpu_features           = CPU_FTRS_44X,
-                .cpu_user_features      = PPC_FEATURE_32 | PPC_FEATURE_HAS_MMU,
+                .cpu_user_features      = COMMON_USER_BOOKE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc440",
         },
         { /* 440GX Rev. C */
                 .pvr_mask               = 0xf0000fff,
                 .pvr_value              = 0x50000892,
                 .cpu_name               = "440GX Rev. C",
                 .cpu_features           = CPU_FTRS_44X,
-                .cpu_user_features      = PPC_FEATURE_32 | PPC_FEATURE_HAS_MMU,
+                .cpu_user_features      = COMMON_USER_BOOKE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc440",
         },
         { /* 440GX Rev. F */
                 .pvr_mask               = 0xf0000fff,
                 .pvr_value              = 0x50000894,
                 .cpu_name               = "440GX Rev. F",
                 .cpu_features           = CPU_FTRS_44X,
-                .cpu_user_features      = PPC_FEATURE_32 | PPC_FEATURE_HAS_MMU,
+                .cpu_user_features      = COMMON_USER_BOOKE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc440",
         },
         { /* 440SP Rev. A */
                 .pvr_mask               = 0xff000fff,
                 .pvr_value              = 0x53000891,
                 .cpu_name               = "440SP Rev. A",
                 .cpu_features           = CPU_FTRS_44X,
-                .cpu_user_features      = PPC_FEATURE_32 | PPC_FEATURE_HAS_MMU,
+                .cpu_user_features      = COMMON_USER_BOOKE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc440",
         },
         { /* 440SPe Rev. A */
                 .pvr_mask               = 0xff000fff,
@@ -934,9 +1011,10 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_name               = "440SPe Rev. A",
                 .cpu_features           = CPU_FTR_SPLIT_ID_CACHE |
                         CPU_FTR_USE_TB,
-                .cpu_user_features      = PPC_FEATURE_32 | PPC_FEATURE_HAS_MMU,
+                .cpu_user_features      = COMMON_USER_BOOKE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc440",
         },
 #endif /* CONFIG_44x */
 #ifdef CONFIG_FSL_BOOKE
@@ -946,10 +1024,11 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_name               = "e200z5",
                 /* xxx - galak: add CPU_FTR_MAYBE_CAN_DOZE */
                 .cpu_features           = CPU_FTRS_E200,
-                .cpu_user_features      = PPC_FEATURE_32 |
-                        PPC_FEATURE_HAS_MMU | PPC_FEATURE_HAS_EFP_SINGLE |
+                .cpu_user_features      = COMMON_USER_BOOKE |
+                        PPC_FEATURE_HAS_EFP_SINGLE |
                         PPC_FEATURE_UNIFIED_CACHE,
                 .dcache_bsize           = 32,
+                .platform               = "ppc5554",
         },
         {       /* e200z6 */
                 .pvr_mask               = 0xfff00000,
@@ -957,11 +1036,12 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_name               = "e200z6",
                 /* xxx - galak: add CPU_FTR_MAYBE_CAN_DOZE */
                 .cpu_features           = CPU_FTRS_E200,
-                .cpu_user_features      = PPC_FEATURE_32 |
-                        PPC_FEATURE_HAS_MMU | PPC_FEATURE_SPE_COMP |
+                .cpu_user_features      = COMMON_USER_BOOKE |
+                        PPC_FEATURE_SPE_COMP |
                         PPC_FEATURE_HAS_EFP_SINGLE |
                         PPC_FEATURE_UNIFIED_CACHE,
                 .dcache_bsize           = 32,
+                .platform               = "ppc5554",
         },
         {       /* e500 */
                 .pvr_mask               = 0xffff0000,
@@ -969,14 +1049,15 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_name               = "e500",
                 /* xxx - galak: add CPU_FTR_MAYBE_CAN_DOZE */
                 .cpu_features           = CPU_FTRS_E500,
-                .cpu_user_features      = PPC_FEATURE_32 |
-                        PPC_FEATURE_HAS_MMU | PPC_FEATURE_SPE_COMP |
+                .cpu_user_features      = COMMON_USER_BOOKE |
+                        PPC_FEATURE_SPE_COMP |
                         PPC_FEATURE_HAS_EFP_SINGLE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
                 .oprofile_cpu_type      = "ppc/e500",
-                .oprofile_type          = BOOKE,
+                .oprofile_type          = PPC_OPROFILE_BOOKE,
+                .platform               = "ppc8540",
         },
         {       /* e500v2 */
                 .pvr_mask               = 0xffff0000,
@@ -984,14 +1065,16 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_name               = "e500v2",
                 /* xxx - galak: add CPU_FTR_MAYBE_CAN_DOZE */
                 .cpu_features           = CPU_FTRS_E500_2,
-                .cpu_user_features      = PPC_FEATURE_32 |
-                        PPC_FEATURE_HAS_MMU | PPC_FEATURE_SPE_COMP |
-                        PPC_FEATURE_HAS_EFP_SINGLE | PPC_FEATURE_HAS_EFP_DOUBLE,
+                .cpu_user_features      = COMMON_USER_BOOKE |
+                        PPC_FEATURE_SPE_COMP |
+                        PPC_FEATURE_HAS_EFP_SINGLE |
+                        PPC_FEATURE_HAS_EFP_DOUBLE,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
                 .oprofile_cpu_type      = "ppc/e500",
-                .oprofile_type          = BOOKE,
+                .oprofile_type          = PPC_OPROFILE_BOOKE,
+                .platform               = "ppc8548",
         },
 #endif
 #if !CLASSIC_PPC
@@ -1003,6 +1086,7 @@ struct cpu_spec	cpu_specs[] = {
                 .cpu_user_features      = PPC_FEATURE_32,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "powerpc",
         }
 #endif /* !CLASSIC_PPC */
 #endif /* CONFIG_PPC32 */
diff --git a/arch/powerpc/kernel/crash.c b/arch/powerpc/kernel/crash.c
index 5f248e3fdf82..8c21d378f5d2 100644
--- a/arch/powerpc/kernel/crash.c
+++ b/arch/powerpc/kernel/crash.c
@@ -84,7 +84,10 @@ static void crash_save_this_cpu(struct pt_regs *regs, int cpu)
          * squirrelled away.  ELF notes happen to provide
          * all of that that no need to invent something new.
          */
-        buf = &crash_notes[cpu][0];
+        buf = (u32*)per_cpu_ptr(crash_notes, cpu);
+        if (!buf) 
+                return;
+
         memset(&prstatus, 0, sizeof(prstatus));
         prstatus.pr_pid = current->pid;
         elf_core_copy_regs(&prstatus.pr_reg, regs);
@@ -93,76 +96,6 @@ static void crash_save_this_cpu(struct pt_regs *regs, int cpu)
         final_note(buf);
 }
 
-/* FIXME Merge this with xmon_save_regs ?? */
-static inline void crash_get_current_regs(struct pt_regs *regs)
-{
-        unsigned long tmp1, tmp2;
-
-        __asm__ __volatile__ (
-                "std    0,0(%2)\n"
-                "std    1,8(%2)\n"
-                "std    2,16(%2)\n"
-                "std    3,24(%2)\n"
-                "std    4,32(%2)\n"
-                "std    5,40(%2)\n"
-                "std    6,48(%2)\n"
-                "std    7,56(%2)\n"
-                "std    8,64(%2)\n"
-                "std    9,72(%2)\n"
-                "std    10,80(%2)\n"
-                "std    11,88(%2)\n"
-                "std    12,96(%2)\n"
-                "std    13,104(%2)\n"
-                "std    14,112(%2)\n"
-                "std    15,120(%2)\n"
-                "std    16,128(%2)\n"
-                "std    17,136(%2)\n"
-                "std    18,144(%2)\n"
-                "std    19,152(%2)\n"
-                "std    20,160(%2)\n"
-                "std    21,168(%2)\n"
-                "std    22,176(%2)\n"
-                "std    23,184(%2)\n"
-                "std    24,192(%2)\n"
-                "std    25,200(%2)\n"
-                "std    26,208(%2)\n"
-                "std    27,216(%2)\n"
-                "std    28,224(%2)\n"
-                "std    29,232(%2)\n"
-                "std    30,240(%2)\n"
-                "std    31,248(%2)\n"
-                "mfmsr  %0\n"
-                "std    %0, 264(%2)\n"
-                "mfctr  %0\n"
-                "std    %0, 280(%2)\n"
-                "mflr   %0\n"
-                "std    %0, 288(%2)\n"
-                "bl     1f\n"
-        "1:      mflr   %1\n"
-                "std    %1, 256(%2)\n"
-                "mtlr   %0\n"
-                "mfxer  %0\n"
-                "std    %0, 296(%2)\n"
-                : "=&r" (tmp1), "=&r" (tmp2)
-                : "b" (regs));
-}
-
-/* We may have saved_regs from where the error came from
- * or it is NULL if via a direct panic().
- */
-static void crash_save_self(struct pt_regs *saved_regs)
-{
-        struct pt_regs regs;
-        int cpu;
-
-        cpu = smp_processor_id();
-        if (saved_regs)
-                memcpy(&regs, saved_regs, sizeof(regs));
-        else
-                crash_get_current_regs(&regs);
-        crash_save_this_cpu(&regs, cpu);
-}
-
 #ifdef CONFIG_SMP
 static atomic_t waiting_for_crash_ipi;
 
@@ -260,5 +193,5 @@ void default_machine_crash_shutdown(struct pt_regs *regs)
          */
         crashing_cpu = smp_processor_id();
         crash_kexec_prepare_cpus();
-        crash_save_self(regs);
+        crash_save_this_cpu(regs, crashing_cpu);
 }
diff --git a/arch/powerpc/kernel/entry_32.S b/arch/powerpc/kernel/entry_32.S
index 036b71d2adfc..d8da2a35c0a4 100644
--- a/arch/powerpc/kernel/entry_32.S
+++ b/arch/powerpc/kernel/entry_32.S
@@ -988,7 +988,7 @@ _GLOBAL(enter_rtas)
         stwu    r1,-INT_FRAME_SIZE(r1)
         mflr    r0
         stw     r0,INT_FRAME_SIZE+4(r1)
-        LOADADDR(r4, rtas)
+        LOAD_REG_ADDR(r4, rtas)
         lis     r6,1f@ha        /* physical return address for rtas */
         addi    r6,r6,1f@l
         tophys(r6,r6)
diff --git a/arch/powerpc/kernel/entry_64.S b/arch/powerpc/kernel/entry_64.S
index aacebb33e98a..542036318866 100644
--- a/arch/powerpc/kernel/entry_64.S
+++ b/arch/powerpc/kernel/entry_64.S
@@ -511,7 +511,8 @@ restore:
         cmpdi   0,r5,0
         beq     4f
         /* Check for pending interrupts (iSeries) */
-        ld      r3,PACALPPACA+LPPACAANYINT(r13)
+        ld      r3,PACALPPACAPTR(r13)
+        ld      r3,LPPACAANYINT(r3)
         cmpdi   r3,0
         beq+    4f                      /* skip do_IRQ if no interrupts */
 
@@ -689,9 +690,8 @@ _GLOBAL(enter_rtas)
         std     r6,PACASAVEDMSR(r13)
 
         /* Setup our real return addr */        
-        SET_REG_TO_LABEL(r4,.rtas_return_loc)
-        SET_REG_TO_CONST(r9,PAGE_OFFSET)
-        sub     r4,r4,r9
+        LOAD_REG_ADDR(r4,.rtas_return_loc)
+        clrldi  r4,r4,2                 /* convert to realmode address */
         mtlr    r4
 
         li      r0,0
@@ -706,7 +706,7 @@ _GLOBAL(enter_rtas)
         sync                            /* disable interrupts so SRR0/1 */
         mtmsrd  r0                      /* don't get trashed */
 
-        SET_REG_TO_LABEL(r4,rtas)
+        LOAD_REG_ADDR(r4, rtas)
         ld      r5,RTASENTRY(r4)        /* get the rtas->entry value */
         ld      r4,RTASBASE(r4)         /* get the rtas->base value */
         
@@ -718,8 +718,7 @@ _GLOBAL(enter_rtas)
 _STATIC(rtas_return_loc)
         /* relocation is off at this point */
         mfspr   r4,SPRN_SPRG3           /* Get PACA */
-        SET_REG_TO_CONST(r5, PAGE_OFFSET)
-        sub     r4,r4,r5                /* RELOC the PACA base pointer */
+        clrldi  r4,r4,2                 /* convert to realmode address */
 
         mfmsr   r6
         li      r0,MSR_RI
@@ -728,7 +727,7 @@ _STATIC(rtas_return_loc)
         mtmsrd  r6
         
         ld      r1,PACAR1(r4)           /* Restore our SP */
-        LOADADDR(r3,.rtas_restore_regs)
+        LOAD_REG_IMMEDIATE(r3,.rtas_restore_regs)
         ld      r4,PACASAVEDMSR(r4)     /* Restore our MSR */
 
         mtspr   SPRN_SRR0,r3
diff --git a/arch/powerpc/kernel/fpu.S b/arch/powerpc/kernel/fpu.S
index b780b42c95fc..e4362dfa37fb 100644
--- a/arch/powerpc/kernel/fpu.S
+++ b/arch/powerpc/kernel/fpu.S
@@ -39,9 +39,9 @@ _GLOBAL(load_up_fpu)
  * to another.  Instead we call giveup_fpu in switch_to.
  */
 #ifndef CONFIG_SMP
-        LOADBASE(r3, last_task_used_math)
+        LOAD_REG_ADDRBASE(r3, last_task_used_math)
         toreal(r3)
-        PPC_LL  r4,OFF(last_task_used_math)(r3)
+        PPC_LL  r4,ADDROFF(last_task_used_math)(r3)
         PPC_LCMPI       0,r4,0
         beq     1f
         toreal(r4)
@@ -77,7 +77,7 @@ _GLOBAL(load_up_fpu)
 #ifndef CONFIG_SMP
         subi    r4,r5,THREAD
         fromreal(r4)
-        PPC_STL r4,OFF(last_task_used_math)(r3)
+        PPC_STL r4,ADDROFF(last_task_used_math)(r3)
 #endif /* CONFIG_SMP */
         /* restore registers and return */
         /* we haven't used ctr or xer or lr */
@@ -113,8 +113,8 @@ _GLOBAL(giveup_fpu)
 1:
 #ifndef CONFIG_SMP
         li      r5,0
-        LOADBASE(r4,last_task_used_math)
-        PPC_STL r5,OFF(last_task_used_math)(r4)
+        LOAD_REG_ADDRBASE(r4,last_task_used_math)
+        PPC_STL r5,ADDROFF(last_task_used_math)(r4)
 #endif /* CONFIG_SMP */
         blr
 
diff --git a/arch/powerpc/kernel/head_64.S b/arch/powerpc/kernel/head_64.S
index 1c066d125375..308268466342 100644
--- a/arch/powerpc/kernel/head_64.S
+++ b/arch/powerpc/kernel/head_64.S
@@ -154,12 +154,12 @@ _GLOBAL(__secondary_hold)
         bne     100b
 
 #ifdef CONFIG_HMT
-        LOADADDR(r4, .hmt_init)
+        SET_REG_IMMEDIATE(r4, .hmt_init)
         mtctr   r4
         bctr
 #else
 #ifdef CONFIG_SMP
-        LOADADDR(r4, .pSeries_secondary_smp_init)
+        LOAD_REG_IMMEDIATE(r4, .pSeries_secondary_smp_init)
         mtctr   r4
         mr      r3,r24
         bctr
@@ -205,9 +205,10 @@ exception_marker:
 #define EX_LR           72
 
 /*
- * We're short on space and time in the exception prolog, so we can't use
- * the normal LOADADDR macro. Normally we just need the low halfword of the
- * address, but for Kdump we need the whole low word.
+ * We're short on space and time in the exception prolog, so we can't
+ * use the normal SET_REG_IMMEDIATE macro. Normally we just need the
+ * low halfword of the address, but for Kdump we need the whole low
+ * word.
  */
 #ifdef CONFIG_CRASH_DUMP
 #define LOAD_HANDLER(reg, label)                                        \
@@ -254,8 +255,9 @@ exception_marker:
 
 #define EXCEPTION_PROLOG_ISERIES_2                                      \
         mfmsr   r10;                                                    \
-        ld      r11,PACALPPACA+LPPACASRR0(r13);                         \
-        ld      r12,PACALPPACA+LPPACASRR1(r13);                         \
+        ld      r12,PACALPPACAPTR(r13);                                 \
+        ld      r11,LPPACASRR0(r12);                                    \
+        ld      r12,LPPACASRR1(r12);                                    \
         ori     r10,r10,MSR_RI;                                         \
         mtmsrd  r10,1
 
@@ -634,7 +636,8 @@ data_access_slb_iSeries:
         std     r12,PACA_EXSLB+EX_R12(r13)
         mfspr   r10,SPRN_SPRG1
         std     r10,PACA_EXSLB+EX_R13(r13)
-        ld      r12,PACALPPACA+LPPACASRR1(r13);
+        ld      r12,PACALPPACAPTR(r13)
+        ld      r12,LPPACASRR1(r12)
         b       .slb_miss_realmode
 
         STD_EXCEPTION_ISERIES(0x400, instruction_access, PACA_EXGEN)
@@ -644,7 +647,8 @@ instruction_access_slb_iSeries:
         mtspr   SPRN_SPRG1,r13          /* save r13 */
         mfspr   r13,SPRN_SPRG3          /* get paca address into r13 */
         std     r3,PACA_EXSLB+EX_R3(r13)
-        ld      r3,PACALPPACA+LPPACASRR0(r13)   /* get SRR0 value */
+        ld      r3,PACALPPACAPTR(r13)
+        ld      r3,LPPACASRR0(r3)       /* get SRR0 value */
         std     r9,PACA_EXSLB+EX_R9(r13)
         mfcr    r9
 #ifdef __DISABLED__
@@ -656,7 +660,8 @@ instruction_access_slb_iSeries:
         std     r12,PACA_EXSLB+EX_R12(r13)
         mfspr   r10,SPRN_SPRG1
         std     r10,PACA_EXSLB+EX_R13(r13)
-        ld      r12,PACALPPACA+LPPACASRR1(r13);
+        ld      r12,PACALPPACAPTR(r13)
+        ld      r12,LPPACASRR1(r12)
         b       .slb_miss_realmode
 
 #ifdef __DISABLED__
@@ -713,7 +718,7 @@ system_reset_iSeries:
         lbz     r23,PACAPROCSTART(r13)  /* Test if this processor
                                          * should start */
         sync
-        LOADADDR(r3,current_set)
+        LOAD_REG_IMMEDIATE(r3,current_set)
         sldi    r28,r24,3               /* get current_set[cpu#] */
         ldx     r3,r3,r28
         addi    r1,r3,THREAD_SIZE
@@ -745,17 +750,19 @@ iSeries_secondary_smp_loop:
         .globl decrementer_iSeries_masked
 decrementer_iSeries_masked:
         li      r11,1
-        stb     r11,PACALPPACA+LPPACADECRINT(r13)
-        LOADBASE(r12,tb_ticks_per_jiffy)
-        lwz     r12,OFF(tb_ticks_per_jiffy)(r12)
+        ld      r12,PACALPPACAPTR(r13)
+        stb     r11,LPPACADECRINT(r12)
+        LOAD_REG_ADDRBASE(r12,tb_ticks_per_jiffy)
+        lwz     r12,ADDROFF(tb_ticks_per_jiffy)(r12)
         mtspr   SPRN_DEC,r12
         /* fall through */
 
         .globl hardware_interrupt_iSeries_masked
 hardware_interrupt_iSeries_masked:
         mtcrf   0x80,r9         /* Restore regs */
-        ld      r11,PACALPPACA+LPPACASRR0(r13)
-        ld      r12,PACALPPACA+LPPACASRR1(r13)
+        ld      r12,PACALPPACAPTR(r13)
+        ld      r11,LPPACASRR0(r12)
+        ld      r12,LPPACASRR1(r12)
         mtspr   SPRN_SRR0,r11
         mtspr   SPRN_SRR1,r12
         ld      r9,PACA_EXGEN+EX_R9(r13)
@@ -994,7 +1001,8 @@ _GLOBAL(slb_miss_realmode)
         ld      r3,PACA_EXSLB+EX_R3(r13)
         lwz     r9,PACA_EXSLB+EX_CCR(r13)       /* get saved CR */
 #ifdef CONFIG_PPC_ISERIES
-        ld      r11,PACALPPACA+LPPACASRR0(r13)  /* get SRR0 value */
+        ld      r11,PACALPPACAPTR(r13)
+        ld      r11,LPPACASRR0(r11)             /* get SRR0 value */
 #endif /* CONFIG_PPC_ISERIES */
 
         mtlr    r10
@@ -1412,7 +1420,7 @@ _GLOBAL(pSeries_secondary_smp_init)
          * 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  */
+        LOAD_REG_IMMEDIATE(r13, paca)   /* Get base vaddr of paca array  */
         li      r5,0                    /* logical cpu id                */
 1:      lhz     r6,PACAHWCPUID(r13)     /* Load HW procid from paca      */
         cmpw    r6,r24                  /* Compare to our id             */
@@ -1446,8 +1454,8 @@ _GLOBAL(pSeries_secondary_smp_init)
 #ifdef CONFIG_PPC_ISERIES
 _STATIC(__start_initialization_iSeries)
         /* Clear out the BSS */
-        LOADADDR(r11,__bss_stop)
-        LOADADDR(r8,__bss_start)
+        LOAD_REG_IMMEDIATE(r11,__bss_stop)
+        LOAD_REG_IMMEDIATE(r8,__bss_start)
         sub     r11,r11,r8              /* bss size                     */
         addi    r11,r11,7               /* round up to an even double word */
         rldicl. r11,r11,61,3            /* shift right by 3             */
@@ -1458,17 +1466,17 @@ _STATIC(__start_initialization_iSeries)
 3:      stdu    r0,8(r8)
         bdnz    3b
 4:
-        LOADADDR(r1,init_thread_union)
+        LOAD_REG_IMMEDIATE(r1,init_thread_union)
         addi    r1,r1,THREAD_SIZE
         li      r0,0
         stdu    r0,-STACK_FRAME_OVERHEAD(r1)
 
-        LOADADDR(r3,cpu_specs)
-        LOADADDR(r4,cur_cpu_spec)
+        LOAD_REG_IMMEDIATE(r3,cpu_specs)
+        LOAD_REG_IMMEDIATE(r4,cur_cpu_spec)
         li      r5,0
         bl      .identify_cpu
 
-        LOADADDR(r2,__toc_start)
+        LOAD_REG_IMMEDIATE(r2,__toc_start)
         addi    r2,r2,0x4000
         addi    r2,r2,0x4000
 
@@ -1528,7 +1536,7 @@ _GLOBAL(__start_initialization_multiplatform)
         li      r24,0
 
         /* Switch off MMU if not already */
-        LOADADDR(r4, .__after_prom_start - KERNELBASE)
+        LOAD_REG_IMMEDIATE(r4, .__after_prom_start - KERNELBASE)
         add     r4,r4,r30
         bl      .__mmu_off
         b       .__after_prom_start
@@ -1548,7 +1556,7 @@ _STATIC(__boot_from_prom)
         /* put a relocation offset into r3 */
         bl      .reloc_offset
 
-        LOADADDR(r2,__toc_start)
+        LOAD_REG_IMMEDIATE(r2,__toc_start)
         addi    r2,r2,0x4000
         addi    r2,r2,0x4000
 
@@ -1588,9 +1596,9 @@ _STATIC(__after_prom_start)
  */
         bl      .reloc_offset
         mr      r26,r3
-        SET_REG_TO_CONST(r27,KERNELBASE)
+        LOAD_REG_IMMEDIATE(r27, KERNELBASE)
 
-        LOADADDR(r3, PHYSICAL_START)    /* target addr */
+        LOAD_REG_IMMEDIATE(r3, PHYSICAL_START)  /* target addr */
 
         // XXX FIXME: Use phys returned by OF (r30)
         add     r4,r27,r26              /* source addr                   */
@@ -1598,7 +1606,7 @@ _STATIC(__after_prom_start)
                                         /*   i.e. where we are running   */
                                         /*      the source addr          */
 
-        LOADADDR(r5,copy_to_here)       /* # bytes of memory to copy     */
+        LOAD_REG_IMMEDIATE(r5,copy_to_here) /* # bytes of memory to copy */
         sub     r5,r5,r27
 
         li      r6,0x100                /* Start offset, the first 0x100 */
@@ -1608,11 +1616,11 @@ _STATIC(__after_prom_start)
                                         /* this includes the code being  */
                                         /* executed here.                */
 
-        LOADADDR(r0, 4f)                /* Jump to the copy of this code */
+        LOAD_REG_IMMEDIATE(r0, 4f)      /* Jump to the copy of this code */
         mtctr   r0                      /* that we just made/relocated   */
         bctr
 
-4:      LOADADDR(r5,klimit)
+4:      LOAD_REG_IMMEDIATE(r5,klimit)
         add     r5,r5,r26
         ld      r5,0(r5)                /* get the value of klimit */
         sub     r5,r5,r27
@@ -1694,7 +1702,7 @@ _GLOBAL(pmac_secondary_start)
         mtmsrd  r3                      /* RI on */
 
         /* Set up a paca value for this processor. */
-        LOADADDR(r4, paca)               /* Get base vaddr of paca array        */
+        LOAD_REG_IMMEDIATE(r4, paca)    /* Get base vaddr of paca array */
         mulli   r13,r24,PACA_SIZE        /* Calculate vaddr of right paca */
         add     r13,r13,r4              /* for this processor.          */
         mtspr   SPRN_SPRG3,r13           /* Save vaddr of paca in SPRG3 */
@@ -1731,7 +1739,7 @@ _GLOBAL(__secondary_start)
         bl      .early_setup_secondary
 
         /* Initialize the kernel stack.  Just a repeat for iSeries.      */
-        LOADADDR(r3,current_set)
+        LOAD_REG_ADDR(r3, current_set)
         sldi    r28,r24,3               /* get current_set[cpu#]         */
         ldx     r1,r3,r28
         addi    r1,r1,THREAD_SIZE-STACK_FRAME_OVERHEAD
@@ -1742,8 +1750,8 @@ _GLOBAL(__secondary_start)
         mtlr    r7
 
         /* enable MMU and jump to start_secondary */
-        LOADADDR(r3,.start_secondary_prolog)
-        SET_REG_TO_CONST(r4, MSR_KERNEL)
+        LOAD_REG_ADDR(r3, .start_secondary_prolog)
+        LOAD_REG_IMMEDIATE(r4, MSR_KERNEL)
 #ifdef DO_SOFT_DISABLE
         ori     r4,r4,MSR_EE
 #endif
@@ -1792,8 +1800,8 @@ _STATIC(start_here_multiplatform)
          * be detached from the kernel completely. Besides, we need
          * to clear it now for kexec-style entry.
          */
-        LOADADDR(r11,__bss_stop)
-        LOADADDR(r8,__bss_start)
+        LOAD_REG_IMMEDIATE(r11,__bss_stop)
+        LOAD_REG_IMMEDIATE(r8,__bss_start)
         sub     r11,r11,r8              /* bss size                     */
         addi    r11,r11,7               /* round up to an even double word */
         rldicl. r11,r11,61,3            /* shift right by 3             */
@@ -1831,7 +1839,7 @@ _STATIC(start_here_multiplatform)
         /* up the htab.  This is done because we have relocated the  */
         /* kernel but are still running in real mode. */
 
-        LOADADDR(r3,init_thread_union)
+        LOAD_REG_IMMEDIATE(r3,init_thread_union)
         add     r3,r3,r26
 
         /* set up a stack pointer (physical address) */
@@ -1840,14 +1848,14 @@ _STATIC(start_here_multiplatform)
         stdu    r0,-STACK_FRAME_OVERHEAD(r1)
 
         /* set up the TOC (physical address) */
-        LOADADDR(r2,__toc_start)
+        LOAD_REG_IMMEDIATE(r2,__toc_start)
         addi    r2,r2,0x4000
         addi    r2,r2,0x4000
         add     r2,r2,r26
 
-        LOADADDR(r3,cpu_specs)
+        LOAD_REG_IMMEDIATE(r3, cpu_specs)
         add     r3,r3,r26
-        LOADADDR(r4,cur_cpu_spec)
+        LOAD_REG_IMMEDIATE(r4,cur_cpu_spec)
         add     r4,r4,r26
         mr      r5,r26
         bl      .identify_cpu
@@ -1863,11 +1871,11 @@ _STATIC(start_here_multiplatform)
          * nowhere it can be initialized differently before we reach this
          * code
          */
-        LOADADDR(r27, boot_cpuid)
+        LOAD_REG_IMMEDIATE(r27, boot_cpuid)
         add     r27,r27,r26
         lwz     r27,0(r27)
 
-        LOADADDR(r24, paca)             /* Get base vaddr of paca array  */
+        LOAD_REG_IMMEDIATE(r24, paca)   /* Get base vaddr of paca array  */
         mulli   r13,r27,PACA_SIZE       /* Calculate vaddr of right paca */
         add     r13,r13,r24             /* for this processor.           */
         add     r13,r13,r26             /* convert to physical addr      */
@@ -1880,8 +1888,8 @@ _STATIC(start_here_multiplatform)
         mr      r3,r31
         bl      .early_setup
 
-        LOADADDR(r3,.start_here_common)
-        SET_REG_TO_CONST(r4, MSR_KERNEL)
+        LOAD_REG_IMMEDIATE(r3, .start_here_common)
+        LOAD_REG_IMMEDIATE(r4, MSR_KERNEL)
         mtspr   SPRN_SRR0,r3
         mtspr   SPRN_SRR1,r4
         rfid
@@ -1895,7 +1903,7 @@ _STATIC(start_here_common)
         /* The following code sets up the SP and TOC now that we are */
         /* running with translation enabled. */
 
-        LOADADDR(r3,init_thread_union)
+        LOAD_REG_IMMEDIATE(r3,init_thread_union)
 
         /* set up the stack */
         addi    r1,r3,THREAD_SIZE
@@ -1908,16 +1916,16 @@ _STATIC(start_here_common)
         li      r3,0
         bl      .do_cpu_ftr_fixups
 
-        LOADADDR(r26, boot_cpuid)
+        LOAD_REG_IMMEDIATE(r26, boot_cpuid)
         lwz     r26,0(r26)
 
-        LOADADDR(r24, paca)             /* Get base vaddr of paca array  */
+        LOAD_REG_IMMEDIATE(r24, paca)   /* Get base vaddr of paca array  */
         mulli   r13,r26,PACA_SIZE       /* Calculate vaddr of right paca */
         add     r13,r13,r24             /* for this processor.           */
         mtspr   SPRN_SPRG3,r13
 
         /* ptr to current */
-        LOADADDR(r4,init_task)
+        LOAD_REG_IMMEDIATE(r4, init_task)
         std     r4,PACACURRENT(r13)
 
         /* Load the TOC */
@@ -1940,7 +1948,7 @@ _STATIC(start_here_common)
 
 _GLOBAL(hmt_init)
 #ifdef CONFIG_HMT
-        LOADADDR(r5, hmt_thread_data)
+        LOAD_REG_IMMEDIATE(r5, hmt_thread_data)
         mfspr   r7,SPRN_PVR
         srwi    r7,r7,16
         cmpwi   r7,0x34                 /* Pulsar  */
@@ -1961,7 +1969,7 @@ _GLOBAL(hmt_init)
         b       101f
 
 __hmt_secondary_hold:
-        LOADADDR(r5, hmt_thread_data)
+        LOAD_REG_IMMEDIATE(r5, hmt_thread_data)
         clrldi  r5,r5,4
         li      r7,0
         mfspr   r6,SPRN_PIR
@@ -1989,7 +1997,7 @@ __hmt_secondary_hold:
 
 #ifdef CONFIG_HMT
 _GLOBAL(hmt_start_secondary)
-        LOADADDR(r4,__hmt_secondary_hold)
+        LOAD_REG_IMMEDIATE(r4,__hmt_secondary_hold)
         clrldi  r4,r4,4
         mtspr   SPRN_NIADORM, r4
         mfspr   r4, SPRN_MSRDORM
diff --git a/arch/powerpc/kernel/idle_power4.S b/arch/powerpc/kernel/idle_power4.S
index 1494e2f177f7..c16b4afab582 100644
--- a/arch/powerpc/kernel/idle_power4.S
+++ b/arch/powerpc/kernel/idle_power4.S
@@ -38,14 +38,14 @@ END_FTR_SECTION_IFCLR(CPU_FTR_CAN_NAP)
         /* We must dynamically check for the NAP feature as it
          * can be cleared by CPU init after the fixups are done
          */
-        LOADBASE(r3,cur_cpu_spec)
-        ld      r4,OFF(cur_cpu_spec)(r3)
+        LOAD_REG_ADDRBASE(r3,cur_cpu_spec)
+        ld      r4,ADDROFF(cur_cpu_spec)(r3)
         ld      r4,CPU_SPEC_FEATURES(r4)
         andi.   r0,r4,CPU_FTR_CAN_NAP
         beqlr
         /* Now check if user or arch enabled NAP mode */
-        LOADBASE(r3,powersave_nap)
-        lwz     r4,OFF(powersave_nap)(r3)
+        LOAD_REG_ADDRBASE(r3,powersave_nap)
+        lwz     r4,ADDROFF(powersave_nap)(r3)
         cmpwi   0,r4,0
         beqlr
 
diff --git a/arch/powerpc/kernel/irq.c b/arch/powerpc/kernel/irq.c
index 5651032d8706..d1fffce86df9 100644
--- a/arch/powerpc/kernel/irq.c
+++ b/arch/powerpc/kernel/irq.c
@@ -238,14 +238,10 @@ void do_IRQ(struct pt_regs *regs)
         irq_exit();
 
 #ifdef CONFIG_PPC_ISERIES
-        {
-                struct paca_struct *lpaca = get_paca();
-
-                if (lpaca->lppaca.int_dword.fields.decr_int) {
-                        lpaca->lppaca.int_dword.fields.decr_int = 0;
-                        /* Signal a fake decrementer interrupt */
-                        timer_interrupt(regs);
-                }
+        if (get_lppaca()->int_dword.fields.decr_int) {
+                get_lppaca()->int_dword.fields.decr_int = 0;
+                /* Signal a fake decrementer interrupt */
+                timer_interrupt(regs);
         }
 #endif
 }
diff --git a/arch/powerpc/kernel/lparcfg.c b/arch/powerpc/kernel/lparcfg.c
index 9dda16ccde78..1ae96a8ed7e2 100644
--- a/arch/powerpc/kernel/lparcfg.c
+++ b/arch/powerpc/kernel/lparcfg.c
@@ -55,15 +55,13 @@ static unsigned long get_purr(void)
 {
         unsigned long sum_purr = 0;
         int cpu;
-        struct paca_struct *lpaca;
 
         for_each_cpu(cpu) {
-                lpaca = paca + cpu;
-                sum_purr += lpaca->lppaca.emulated_time_base;
+                sum_purr += lppaca[cpu].emulated_time_base;
 
 #ifdef PURR_DEBUG
                 printk(KERN_INFO "get_purr for cpu (%d) has value (%ld) \n",
-                        cpu, lpaca->lppaca.emulated_time_base);
+                        cpu, lppaca[cpu].emulated_time_base);
 #endif
         }
         return sum_purr;
@@ -79,12 +77,11 @@ static int lparcfg_data(struct seq_file *m, void *v)
         unsigned long pool_id, lp_index;
         int shared, entitled_capacity, max_entitled_capacity;
         int processors, max_processors;
-        struct paca_struct *lpaca = get_paca();
         unsigned long purr = get_purr();
 
         seq_printf(m, "%s %s \n", MODULE_NAME, MODULE_VERS);
 
-        shared = (int)(lpaca->lppaca_ptr->shared_proc);
+        shared = (int)(get_lppaca()->shared_proc);
         seq_printf(m, "serial_number=%c%c%c%c%c%c%c\n",
                    e2a(xItExtVpdPanel.mfgID[2]),
                    e2a(xItExtVpdPanel.mfgID[3]),
@@ -402,7 +399,7 @@ static int lparcfg_data(struct seq_file *m, void *v)
                            (h_resource >> 0 * 8) & 0xffff);
 
                 /* pool related entries are apropriate for shared configs */
-                if (paca[0].lppaca.shared_proc) {
+                if (lppaca[0].shared_proc) {
 
                         h_pic(&pool_idle_time, &pool_procs);
 
@@ -451,7 +448,7 @@ static int lparcfg_data(struct seq_file *m, void *v)
         seq_printf(m, "partition_potential_processors=%d\n",
                    partition_potential_processors);
 
-        seq_printf(m, "shared_processor_mode=%d\n", paca[0].lppaca.shared_proc);
+        seq_printf(m, "shared_processor_mode=%d\n", lppaca[0].shared_proc);
 
         return 0;
 }
diff --git a/arch/powerpc/kernel/misc_32.S b/arch/powerpc/kernel/misc_32.S
index 01d0d97a16e1..be982023409e 100644
--- a/arch/powerpc/kernel/misc_32.S
+++ b/arch/powerpc/kernel/misc_32.S
@@ -68,7 +68,7 @@ _GLOBAL(reloc_offset)
         mflr    r0
         bl      1f
 1:      mflr    r3
-        LOADADDR(r4,1b)
+        LOAD_REG_IMMEDIATE(r4,1b)
         subf    r3,r4,r3
         mtlr    r0
         blr
@@ -80,7 +80,7 @@ _GLOBAL(add_reloc_offset)
         mflr    r0
         bl      1f
 1:      mflr    r5
-        LOADADDR(r4,1b)
+        LOAD_REG_IMMEDIATE(r4,1b)
         subf    r5,r4,r5
         add     r3,r3,r5
         mtlr    r0
diff --git a/arch/powerpc/kernel/misc_64.S b/arch/powerpc/kernel/misc_64.S
index ae48a002f81a..2778cce058e2 100644
--- a/arch/powerpc/kernel/misc_64.S
+++ b/arch/powerpc/kernel/misc_64.S
@@ -39,7 +39,7 @@ _GLOBAL(reloc_offset)
         mflr    r0
         bl      1f
 1:      mflr    r3
-        LOADADDR(r4,1b)
+        LOAD_REG_IMMEDIATE(r4,1b)
         subf    r3,r4,r3
         mtlr    r0
         blr
@@ -51,7 +51,7 @@ _GLOBAL(add_reloc_offset)
         mflr    r0
         bl      1f
 1:      mflr    r5
-        LOADADDR(r4,1b)
+        LOAD_REG_IMMEDIATE(r4,1b)
         subf    r5,r4,r5
         add     r3,r3,r5
         mtlr    r0
@@ -498,15 +498,15 @@ _GLOBAL(identify_cpu)
  */
 _GLOBAL(do_cpu_ftr_fixups)
         /* Get CPU 0 features */
-        LOADADDR(r6,cur_cpu_spec)
+        LOAD_REG_IMMEDIATE(r6,cur_cpu_spec)
         sub     r6,r6,r3
         ld      r4,0(r6)
         sub     r4,r4,r3
         ld      r4,CPU_SPEC_FEATURES(r4)
         /* Get the fixup table */
-        LOADADDR(r6,__start___ftr_fixup)
+        LOAD_REG_IMMEDIATE(r6,__start___ftr_fixup)
         sub     r6,r6,r3
-        LOADADDR(r7,__stop___ftr_fixup)
+        LOAD_REG_IMMEDIATE(r7,__stop___ftr_fixup)
         sub     r7,r7,r3
         /* Do the fixup */
 1:      cmpld   r6,r7
diff --git a/arch/powerpc/kernel/of_device.c b/arch/powerpc/kernel/of_device.c
index 7065e40e2f42..22d83d4d1af5 100644
--- a/arch/powerpc/kernel/of_device.c
+++ b/arch/powerpc/kernel/of_device.c
@@ -132,6 +132,8 @@ static int of_device_resume(struct device * dev)
 struct bus_type of_platform_bus_type = {
        .name    = "of_platform",
        .match   = of_platform_bus_match,
+       .probe   = of_device_probe,
+       .remove  = of_device_remove,
        .suspend = of_device_suspend,
        .resume  = of_device_resume,
 };
@@ -150,8 +152,6 @@ int of_register_driver(struct of_platform_driver *drv)
         /* initialize common driver fields */
         drv->driver.name = drv->name;
         drv->driver.bus = &of_platform_bus_type;
-        drv->driver.probe = of_device_probe;
-        drv->driver.remove = of_device_remove;
 
         /* register with core */
         count = driver_register(&drv->driver);
diff --git a/arch/powerpc/kernel/paca.c b/arch/powerpc/kernel/paca.c
index 999bdd816769..5d1b708086bd 100644
--- a/arch/powerpc/kernel/paca.c
+++ b/arch/powerpc/kernel/paca.c
@@ -25,6 +25,28 @@
  * field correctly */
 extern unsigned long __toc_start;
 
+/*
+ * iSeries structure which the hypervisor knows about - this structure
+ * should not cross a page boundary.  The vpa_init/register_vpa call
+ * is now known to fail if the lppaca structure crosses a page
+ * boundary.  The lppaca is also used on POWER5 pSeries boxes.  The
+ * lppaca is 640 bytes long, and cannot readily change since the
+ * hypervisor knows its layout, so a 1kB alignment will suffice to
+ * ensure that it doesn't cross a page boundary.
+ */
+struct lppaca lppaca[] = {
+        [0 ... (NR_CPUS-1)] = {
+                .desc = 0xd397d781,     /* "LpPa" */
+                .size = sizeof(struct lppaca),
+                .dyn_proc_status = 2,
+                .decr_val = 0x00ff0000,
+                .fpregs_in_use = 1,
+                .end_of_quantum = 0xfffffffffffffffful,
+                .slb_count = 64,
+                .vmxregs_in_use = 0,
+        },
+};
+
 /* The Paca is an array with one entry per processor.  Each contains an
  * lppaca, which contains the information shared between the
  * hypervisor and Linux.
@@ -35,27 +57,17 @@ extern unsigned long __toc_start;
  * processor (not thread).
  */
 #define PACA_INIT_COMMON(number, start, asrr, asrv)                         \
+        .lppaca_ptr = &lppaca[number],                                      \
         .lock_token = 0x8000,                                               \
         .paca_index = (number),         /* Paca Index */                    \
         .kernel_toc = (unsigned long)(&__toc_start) + 0x8000UL,             \
         .stab_real = (asrr),            /* Real pointer to segment table */ \
         .stab_addr = (asrv),            /* Virt pointer to segment table */ \
         .cpu_start = (start),           /* Processor start */               \
-        .hw_cpu_id = 0xffff,                                                \
-        .lppaca = {                                                         \
-                .desc = 0xd397d781,     /* "LpPa" */                        \
-                .size = sizeof(struct lppaca),                              \
-                .dyn_proc_status = 2,                                       \
-                .decr_val = 0x00ff0000,                                     \
-                .fpregs_in_use = 1,                                         \
-                .end_of_quantum = 0xfffffffffffffffful,                     \
-                .slb_count = 64,                                            \
-                .vmxregs_in_use = 0,                                        \
-        },                                                                  \
+        .hw_cpu_id = 0xffff,
 
 #ifdef CONFIG_PPC_ISERIES
 #define PACA_INIT_ISERIES(number)                                           \
-        .lppaca_ptr = &paca[number].lppaca,                                 \
         .reg_save_ptr = &iseries_reg_save[number],
 
 #define PACA_INIT(number)                                                   \
diff --git a/arch/powerpc/kernel/pci_32.c b/arch/powerpc/kernel/pci_32.c
new file mode 100644
index 000000000000..704c846b2b0f
--- /dev/null
+++ b/arch/powerpc/kernel/pci_32.c
@@ -0,0 +1,1897 @@
+/*
+ * Common pmac/prep/chrp pci routines. -- Cort
+ */
+
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <linux/string.h>
+#include <linux/init.h>
+#include <linux/capability.h>
+#include <linux/sched.h>
+#include <linux/errno.h>
+#include <linux/bootmem.h>
+
+#include <asm/processor.h>
+#include <asm/io.h>
+#include <asm/prom.h>
+#include <asm/sections.h>
+#include <asm/pci-bridge.h>
+#include <asm/byteorder.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+#include <asm/machdep.h>
+
+#undef DEBUG
+
+#ifdef DEBUG
+#define DBG(x...) printk(x)
+#else
+#define DBG(x...)
+#endif
+
+unsigned long isa_io_base     = 0;
+unsigned long isa_mem_base    = 0;
+unsigned long pci_dram_offset = 0;
+int pcibios_assign_bus_offset = 1;
+
+void pcibios_make_OF_bus_map(void);
+
+static int pci_relocate_bridge_resource(struct pci_bus *bus, int i);
+static int probe_resource(struct pci_bus *parent, struct resource *pr,
+                          struct resource *res, struct resource **conflict);
+static void update_bridge_base(struct pci_bus *bus, int i);
+static void pcibios_fixup_resources(struct pci_dev* dev);
+static void fixup_broken_pcnet32(struct pci_dev* dev);
+static int reparent_resources(struct resource *parent, struct resource *res);
+static void fixup_cpc710_pci64(struct pci_dev* dev);
+#ifdef CONFIG_PPC_OF
+static u8* pci_to_OF_bus_map;
+#endif
+
+/* By default, we don't re-assign bus numbers. We do this only on
+ * some pmacs
+ */
+int pci_assign_all_buses;
+
+struct pci_controller* hose_head;
+struct pci_controller** hose_tail = &hose_head;
+
+static int pci_bus_count;
+
+static void
+fixup_broken_pcnet32(struct pci_dev* dev)
+{
+        if ((dev->class>>8 == PCI_CLASS_NETWORK_ETHERNET)) {
+                dev->vendor = PCI_VENDOR_ID_AMD;
+                pci_write_config_word(dev, PCI_VENDOR_ID, PCI_VENDOR_ID_AMD);
+        }
+}
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_TRIDENT, PCI_ANY_ID,                     fixup_broken_pcnet32);
+
+static void
+fixup_cpc710_pci64(struct pci_dev* dev)
+{
+        /* Hide the PCI64 BARs from the kernel as their content doesn't
+         * fit well in the resource management
+         */
+        dev->resource[0].start = dev->resource[0].end = 0;
+        dev->resource[0].flags = 0;
+        dev->resource[1].start = dev->resource[1].end = 0;
+        dev->resource[1].flags = 0;
+}
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_IBM,     PCI_DEVICE_ID_IBM_CPC710_PCI64, fixup_cpc710_pci64);
+
+static void
+pcibios_fixup_resources(struct pci_dev *dev)
+{
+        struct pci_controller* hose = (struct pci_controller *)dev->sysdata;
+        int i;
+        unsigned long offset;
+
+        if (!hose) {
+                printk(KERN_ERR "No hose for PCI dev %s!\n", pci_name(dev));
+                return;
+        }
+        for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
+                struct resource *res = dev->resource + i;
+                if (!res->flags)
+                        continue;
+                if (res->end == 0xffffffff) {
+                        DBG("PCI:%s Resource %d [%08lx-%08lx] is unassigned\n",
+                            pci_name(dev), i, res->start, res->end);
+                        res->end -= res->start;
+                        res->start = 0;
+                        res->flags |= IORESOURCE_UNSET;
+                        continue;
+                }
+                offset = 0;
+                if (res->flags & IORESOURCE_MEM) {
+                        offset = hose->pci_mem_offset;
+                } else if (res->flags & IORESOURCE_IO) {
+                        offset = (unsigned long) hose->io_base_virt
+                                - isa_io_base;
+                }
+                if (offset != 0) {
+                        res->start += offset;
+                        res->end += offset;
+#ifdef DEBUG
+                        printk("Fixup res %d (%lx) of dev %s: %lx -> %lx\n",
+                               i, res->flags, pci_name(dev),
+                               res->start - offset, res->start);
+#endif
+                }
+        }
+
+        /* Call machine specific resource fixup */
+        if (ppc_md.pcibios_fixup_resources)
+                ppc_md.pcibios_fixup_resources(dev);
+}
+DECLARE_PCI_FIXUP_HEADER(PCI_ANY_ID,            PCI_ANY_ID,                     pcibios_fixup_resources);
+
+void pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
+                        struct resource *res)
+{
+        unsigned long offset = 0;
+        struct pci_controller *hose = dev->sysdata;
+
+        if (hose && res->flags & IORESOURCE_IO)
+                offset = (unsigned long)hose->io_base_virt - isa_io_base;
+        else if (hose && res->flags & IORESOURCE_MEM)
+                offset = hose->pci_mem_offset;
+        region->start = res->start - offset;
+        region->end = res->end - offset;
+}
+EXPORT_SYMBOL(pcibios_resource_to_bus);
+
+void pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
+                             struct pci_bus_region *region)
+{
+        unsigned long offset = 0;
+        struct pci_controller *hose = dev->sysdata;
+
+        if (hose && res->flags & IORESOURCE_IO)
+                offset = (unsigned long)hose->io_base_virt - isa_io_base;
+        else if (hose && res->flags & IORESOURCE_MEM)
+                offset = hose->pci_mem_offset;
+        res->start = region->start + offset;
+        res->end = region->end + offset;
+}
+EXPORT_SYMBOL(pcibios_bus_to_resource);
+
+/*
+ * We need to avoid collisions with `mirrored' VGA ports
+ * and other strange ISA hardware, so we always want the
+ * addresses to be allocated in the 0x000-0x0ff region
+ * modulo 0x400.
+ *
+ * Why? Because some silly external IO cards only decode
+ * the low 10 bits of the IO address. The 0x00-0xff region
+ * is reserved for motherboard devices that decode all 16
+ * bits, so it's ok to allocate at, say, 0x2800-0x28ff,
+ * but we want to try to avoid allocating at 0x2900-0x2bff
+ * which might have be mirrored at 0x0100-0x03ff..
+ */
+void pcibios_align_resource(void *data, struct resource *res, unsigned long size,
+                       unsigned long align)
+{
+        struct pci_dev *dev = data;
+
+        if (res->flags & IORESOURCE_IO) {
+                unsigned long start = res->start;
+
+                if (size > 0x100) {
+                        printk(KERN_ERR "PCI: I/O Region %s/%d too large"
+                               " (%ld bytes)\n", pci_name(dev),
+                               dev->resource - res, size);
+                }
+
+                if (start & 0x300) {
+                        start = (start + 0x3ff) & ~0x3ff;
+                        res->start = start;
+                }
+        }
+}
+EXPORT_SYMBOL(pcibios_align_resource);
+
+/*
+ *  Handle resources of PCI devices.  If the world were perfect, we could
+ *  just allocate all the resource regions and do nothing more.  It isn't.
+ *  On the other hand, we cannot just re-allocate all devices, as it would
+ *  require us to know lots of host bridge internals.  So we attempt to
+ *  keep as much of the original configuration as possible, but tweak it
+ *  when it's found to be wrong.
+ *
+ *  Known BIOS problems we have to work around:
+ *      - I/O or memory regions not configured
+ *      - regions configured, but not enabled in the command register
+ *      - bogus I/O addresses above 64K used
+ *      - expansion ROMs left enabled (this may sound harmless, but given
+ *        the fact the PCI specs explicitly allow address decoders to be
+ *        shared between expansion ROMs and other resource regions, it's
+ *        at least dangerous)
+ *
+ *  Our solution:
+ *      (1) Allocate resources for all buses behind PCI-to-PCI bridges.
+ *          This gives us fixed barriers on where we can allocate.
+ *      (2) Allocate resources for all enabled devices.  If there is
+ *          a collision, just mark the resource as unallocated. Also
+ *          disable expansion ROMs during this step.
+ *      (3) Try to allocate resources for disabled devices.  If the
+ *          resources were assigned correctly, everything goes well,
+ *          if they weren't, they won't disturb allocation of other
+ *          resources.
+ *      (4) Assign new addresses to resources which were either
+ *          not configured at all or misconfigured.  If explicitly
+ *          requested by the user, configure expansion ROM address
+ *          as well.
+ */
+
+static void __init
+pcibios_allocate_bus_resources(struct list_head *bus_list)
+{
+        struct pci_bus *bus;
+        int i;
+        struct resource *res, *pr;
+
+        /* Depth-First Search on bus tree */
+        list_for_each_entry(bus, bus_list, node) {
+                for (i = 0; i < 4; ++i) {
+                        if ((res = bus->resource[i]) == NULL || !res->flags
+                            || res->start > res->end)
+                                continue;
+                        if (bus->parent == NULL)
+                                pr = (res->flags & IORESOURCE_IO)?
+                                        &ioport_resource: &iomem_resource;
+                        else {
+                                pr = pci_find_parent_resource(bus->self, res);
+                                if (pr == res) {
+                                        /* this happens when the generic PCI
+                                         * code (wrongly) decides that this
+                                         * bridge is transparent  -- paulus
+                                         */
+                                        continue;
+                                }
+                        }
+
+                        DBG("PCI: bridge rsrc %lx..%lx (%lx), parent %p\n",
+                            res->start, res->end, res->flags, pr);
+                        if (pr) {
+                                if (request_resource(pr, res) == 0)
+                                        continue;
+                                /*
+                                 * Must be a conflict with an existing entry.
+                                 * Move that entry (or entries) under the
+                                 * bridge resource and try again.
+                                 */
+                                if (reparent_resources(pr, res) == 0)
+                                        continue;
+                        }
+                        printk(KERN_ERR "PCI: Cannot allocate resource region "
+                               "%d of PCI bridge %d\n", i, bus->number);
+                        if (pci_relocate_bridge_resource(bus, i))
+                                bus->resource[i] = NULL;
+                }
+                pcibios_allocate_bus_resources(&bus->children);
+        }
+}
+
+/*
+ * Reparent resource children of pr that conflict with res
+ * under res, and make res replace those children.
+ */
+static int __init
+reparent_resources(struct resource *parent, struct resource *res)
+{
+        struct resource *p, **pp;
+        struct resource **firstpp = NULL;
+
+        for (pp = &parent->child; (p = *pp) != NULL; pp = &p->sibling) {
+                if (p->end < res->start)
+                        continue;
+                if (res->end < p->start)
+                        break;
+                if (p->start < res->start || p->end > res->end)
+                        return -1;      /* not completely contained */
+                if (firstpp == NULL)
+                        firstpp = pp;
+        }
+        if (firstpp == NULL)
+                return -1;      /* didn't find any conflicting entries? */
+        res->parent = parent;
+        res->child = *firstpp;
+        res->sibling = *pp;
+        *firstpp = res;
+        *pp = NULL;
+        for (p = res->child; p != NULL; p = p->sibling) {
+                p->parent = res;
+                DBG(KERN_INFO "PCI: reparented %s [%lx..%lx] under %s\n",
+                    p->name, p->start, p->end, res->name);
+        }
+        return 0;
+}
+
+/*
+ * A bridge has been allocated a range which is outside the range
+ * of its parent bridge, so it needs to be moved.
+ */
+static int __init
+pci_relocate_bridge_resource(struct pci_bus *bus, int i)
+{
+        struct resource *res, *pr, *conflict;
+        unsigned long try, size;
+        int j;
+        struct pci_bus *parent = bus->parent;
+
+        if (parent == NULL) {
+                /* shouldn't ever happen */
+                printk(KERN_ERR "PCI: can't move host bridge resource\n");
+                return -1;
+        }
+        res = bus->resource[i];
+        if (res == NULL)
+                return -1;
+        pr = NULL;
+        for (j = 0; j < 4; j++) {
+                struct resource *r = parent->resource[j];
+                if (!r)
+                        continue;
+                if ((res->flags ^ r->flags) & (IORESOURCE_IO | IORESOURCE_MEM))
+                        continue;
+                if (!((res->flags ^ r->flags) & IORESOURCE_PREFETCH)) {
+                        pr = r;
+                        break;
+                }
+                if (res->flags & IORESOURCE_PREFETCH)
+                        pr = r;
+        }
+        if (pr == NULL)
+                return -1;
+        size = res->end - res->start;
+        if (pr->start > pr->end || size > pr->end - pr->start)
+                return -1;
+        try = pr->end;
+        for (;;) {
+                res->start = try - size;
+                res->end = try;
+                if (probe_resource(bus->parent, pr, res, &conflict) == 0)
+                        break;
+                if (conflict->start <= pr->start + size)
+                        return -1;
+                try = conflict->start - 1;
+        }
+        if (request_resource(pr, res)) {
+                DBG(KERN_ERR "PCI: huh? couldn't move to %lx..%lx\n",
+                    res->start, res->end);
+                return -1;              /* "can't happen" */
+        }
+        update_bridge_base(bus, i);
+        printk(KERN_INFO "PCI: bridge %d resource %d moved to %lx..%lx\n",
+               bus->number, i, res->start, res->end);
+        return 0;
+}
+
+static int __init
+probe_resource(struct pci_bus *parent, struct resource *pr,
+               struct resource *res, struct resource **conflict)
+{
+        struct pci_bus *bus;
+        struct pci_dev *dev;
+        struct resource *r;
+        int i;
+
+        for (r = pr->child; r != NULL; r = r->sibling) {
+                if (r->end >= res->start && res->end >= r->start) {
+                        *conflict = r;
+                        return 1;
+                }
+        }
+        list_for_each_entry(bus, &parent->children, node) {
+                for (i = 0; i < 4; ++i) {
+                        if ((r = bus->resource[i]) == NULL)
+                                continue;
+                        if (!r->flags || r->start > r->end || r == res)
+                                continue;
+                        if (pci_find_parent_resource(bus->self, r) != pr)
+                                continue;
+                        if (r->end >= res->start && res->end >= r->start) {
+                                *conflict = r;
+                                return 1;
+                        }
+                }
+        }
+        list_for_each_entry(dev, &parent->devices, bus_list) {
+                for (i = 0; i < 6; ++i) {
+                        r = &dev->resource[i];
+                        if (!r->flags || (r->flags & IORESOURCE_UNSET))
+                                continue;
+                        if (pci_find_parent_resource(dev, r) != pr)
+                                continue;
+                        if (r->end >= res->start && res->end >= r->start) {
+                                *conflict = r;
+                                return 1;
+                        }
+                }
+        }
+        return 0;
+}
+
+static void __init
+update_bridge_base(struct pci_bus *bus, int i)
+{
+        struct resource *res = bus->resource[i];
+        u8 io_base_lo, io_limit_lo;
+        u16 mem_base, mem_limit;
+        u16 cmd;
+        unsigned long start, end, off;
+        struct pci_dev *dev = bus->self;
+        struct pci_controller *hose = dev->sysdata;
+
+        if (!hose) {
+                printk("update_bridge_base: no hose?\n");
+                return;
+        }
+        pci_read_config_word(dev, PCI_COMMAND, &cmd);
+        pci_write_config_word(dev, PCI_COMMAND,
+                              cmd & ~(PCI_COMMAND_IO | PCI_COMMAND_MEMORY));
+        if (res->flags & IORESOURCE_IO) {
+                off = (unsigned long) hose->io_base_virt - isa_io_base;
+                start = res->start - off;
+                end = res->end - off;
+                io_base_lo = (start >> 8) & PCI_IO_RANGE_MASK;
+                io_limit_lo = (end >> 8) & PCI_IO_RANGE_MASK;
+                if (end > 0xffff) {
+                        pci_write_config_word(dev, PCI_IO_BASE_UPPER16,
+                                              start >> 16);
+                        pci_write_config_word(dev, PCI_IO_LIMIT_UPPER16,
+                                              end >> 16);
+                        io_base_lo |= PCI_IO_RANGE_TYPE_32;
+                } else
+                        io_base_lo |= PCI_IO_RANGE_TYPE_16;
+                pci_write_config_byte(dev, PCI_IO_BASE, io_base_lo);
+                pci_write_config_byte(dev, PCI_IO_LIMIT, io_limit_lo);
+
+        } else if ((res->flags & (IORESOURCE_MEM | IORESOURCE_PREFETCH))
+                   == IORESOURCE_MEM) {
+                off = hose->pci_mem_offset;
+                mem_base = ((res->start - off) >> 16) & PCI_MEMORY_RANGE_MASK;
+                mem_limit = ((res->end - off) >> 16) & PCI_MEMORY_RANGE_MASK;
+                pci_write_config_word(dev, PCI_MEMORY_BASE, mem_base);
+                pci_write_config_word(dev, PCI_MEMORY_LIMIT, mem_limit);
+
+        } else if ((res->flags & (IORESOURCE_MEM | IORESOURCE_PREFETCH))
+                   == (IORESOURCE_MEM | IORESOURCE_PREFETCH)) {
+                off = hose->pci_mem_offset;
+                mem_base = ((res->start - off) >> 16) & PCI_PREF_RANGE_MASK;
+                mem_limit = ((res->end - off) >> 16) & PCI_PREF_RANGE_MASK;
+                pci_write_config_word(dev, PCI_PREF_MEMORY_BASE, mem_base);
+                pci_write_config_word(dev, PCI_PREF_MEMORY_LIMIT, mem_limit);
+
+        } else {
+                DBG(KERN_ERR "PCI: ugh, bridge %s res %d has flags=%lx\n",
+                    pci_name(dev), i, res->flags);
+        }
+        pci_write_config_word(dev, PCI_COMMAND, cmd);
+}
+
+static inline void alloc_resource(struct pci_dev *dev, int idx)
+{
+        struct resource *pr, *r = &dev->resource[idx];
+
+        DBG("PCI:%s: Resource %d: %08lx-%08lx (f=%lx)\n",
+            pci_name(dev), idx, r->start, r->end, r->flags);
+        pr = pci_find_parent_resource(dev, r);
+        if (!pr || request_resource(pr, r) < 0) {
+                printk(KERN_ERR "PCI: Cannot allocate resource region %d"
+                       " of device %s\n", idx, pci_name(dev));
+                if (pr)
+                        DBG("PCI:  parent is %p: %08lx-%08lx (f=%lx)\n",
+                            pr, pr->start, pr->end, pr->flags);
+                /* We'll assign a new address later */
+                r->flags |= IORESOURCE_UNSET;
+                r->end -= r->start;
+                r->start = 0;
+        }
+}
+
+static void __init
+pcibios_allocate_resources(int pass)
+{
+        struct pci_dev *dev = NULL;
+        int idx, disabled;
+        u16 command;
+        struct resource *r;
+
+        for_each_pci_dev(dev) {
+                pci_read_config_word(dev, PCI_COMMAND, &command);
+                for (idx = 0; idx < 6; idx++) {
+                        r = &dev->resource[idx];
+                        if (r->parent)          /* Already allocated */
+                                continue;
+                        if (!r->flags || (r->flags & IORESOURCE_UNSET))
+                                continue;       /* Not assigned at all */
+                        if (r->flags & IORESOURCE_IO)
+                                disabled = !(command & PCI_COMMAND_IO);
+                        else
+                                disabled = !(command & PCI_COMMAND_MEMORY);
+                        if (pass == disabled)
+                                alloc_resource(dev, idx);
+                }
+                if (pass)
+                        continue;
+                r = &dev->resource[PCI_ROM_RESOURCE];
+                if (r->flags & IORESOURCE_ROM_ENABLE) {
+                        /* Turn the ROM off, leave the resource region, but keep it unregistered. */
+                        u32 reg;
+                        DBG("PCI: Switching off ROM of %s\n", pci_name(dev));
+                        r->flags &= ~IORESOURCE_ROM_ENABLE;
+                        pci_read_config_dword(dev, dev->rom_base_reg, &reg);
+                        pci_write_config_dword(dev, dev->rom_base_reg,
+                                               reg & ~PCI_ROM_ADDRESS_ENABLE);
+                }
+        }
+}
+
+static void __init
+pcibios_assign_resources(void)
+{
+        struct pci_dev *dev = NULL;
+        int idx;
+        struct resource *r;
+
+        for_each_pci_dev(dev) {
+                int class = dev->class >> 8;
+
+                /* Don't touch classless devices and host bridges */
+                if (!class || class == PCI_CLASS_BRIDGE_HOST)
+                        continue;
+
+                for (idx = 0; idx < 6; idx++) {
+                        r = &dev->resource[idx];
+
+                        /*
+                         * We shall assign a new address to this resource,
+                         * either because the BIOS (sic) forgot to do so
+                         * or because we have decided the old address was
+                         * unusable for some reason.
+                         */
+                        if ((r->flags & IORESOURCE_UNSET) && r->end &&
+                            (!ppc_md.pcibios_enable_device_hook ||
+                             !ppc_md.pcibios_enable_device_hook(dev, 1))) {
+                                r->flags &= ~IORESOURCE_UNSET;
+                                pci_assign_resource(dev, idx);
+                        }
+                }
+
+#if 0 /* don't assign ROMs */
+                r = &dev->resource[PCI_ROM_RESOURCE];
+                r->end -= r->start;
+                r->start = 0;
+                if (r->end)
+                        pci_assign_resource(dev, PCI_ROM_RESOURCE);
+#endif
+        }
+}
+
+
+int
+pcibios_enable_resources(struct pci_dev *dev, int mask)
+{
+        u16 cmd, old_cmd;
+        int idx;
+        struct resource *r;
+
+        pci_read_config_word(dev, PCI_COMMAND, &cmd);
+        old_cmd = cmd;
+        for (idx=0; idx<6; idx++) {
+                /* Only set up the requested stuff */
+                if (!(mask & (1<<idx)))
+                        continue;
+        
+                r = &dev->resource[idx];
+                if (r->flags & IORESOURCE_UNSET) {
+                        printk(KERN_ERR "PCI: Device %s not available because of resource collisions\n", pci_name(dev));
+                        return -EINVAL;
+                }
+                if (r->flags & IORESOURCE_IO)
+                        cmd |= PCI_COMMAND_IO;
+                if (r->flags & IORESOURCE_MEM)
+                        cmd |= PCI_COMMAND_MEMORY;
+        }
+        if (dev->resource[PCI_ROM_RESOURCE].start)
+                cmd |= PCI_COMMAND_MEMORY;
+        if (cmd != old_cmd) {
+                printk("PCI: Enabling device %s (%04x -> %04x)\n", pci_name(dev), old_cmd, cmd);
+                pci_write_config_word(dev, PCI_COMMAND, cmd);
+        }
+        return 0;
+}
+
+static int next_controller_index;
+
+struct pci_controller * __init
+pcibios_alloc_controller(void)
+{
+        struct pci_controller *hose;
+
+        hose = (struct pci_controller *)alloc_bootmem(sizeof(*hose));
+        memset(hose, 0, sizeof(struct pci_controller));
+
+        *hose_tail = hose;
+        hose_tail = &hose->next;
+
+        hose->index = next_controller_index++;
+
+        return hose;
+}
+
+#ifdef CONFIG_PPC_OF
+/*
+ * Functions below are used on OpenFirmware machines.
+ */
+static void
+make_one_node_map(struct device_node* node, u8 pci_bus)
+{
+        int *bus_range;
+        int len;
+
+        if (pci_bus >= pci_bus_count)
+                return;
+        bus_range = (int *) get_property(node, "bus-range", &len);
+        if (bus_range == NULL || len < 2 * sizeof(int)) {
+                printk(KERN_WARNING "Can't get bus-range for %s, "
+                       "assuming it starts at 0\n", node->full_name);
+                pci_to_OF_bus_map[pci_bus] = 0;
+        } else
+                pci_to_OF_bus_map[pci_bus] = bus_range[0];
+
+        for (node=node->child; node != 0;node = node->sibling) {
+                struct pci_dev* dev;
+                unsigned int *class_code, *reg;
+        
+                class_code = (unsigned int *) get_property(node, "class-code", NULL);
+                if (!class_code || ((*class_code >> 8) != PCI_CLASS_BRIDGE_PCI &&
+                        (*class_code >> 8) != PCI_CLASS_BRIDGE_CARDBUS))
+                        continue;
+                reg = (unsigned int *)get_property(node, "reg", NULL);
+                if (!reg)
+                        continue;
+                dev = pci_find_slot(pci_bus, ((reg[0] >> 8) & 0xff));
+                if (!dev || !dev->subordinate)
+                        continue;
+                make_one_node_map(node, dev->subordinate->number);
+        }
+}
+        
+void
+pcibios_make_OF_bus_map(void)
+{
+        int i;
+        struct pci_controller* hose;
+        u8* of_prop_map;
+
+        pci_to_OF_bus_map = (u8*)kmalloc(pci_bus_count, GFP_KERNEL);
+        if (!pci_to_OF_bus_map) {
+                printk(KERN_ERR "Can't allocate OF bus map !\n");
+                return;
+        }
+
+        /* We fill the bus map with invalid values, that helps
+         * debugging.
+         */
+        for (i=0; i<pci_bus_count; i++)
+                pci_to_OF_bus_map[i] = 0xff;
+
+        /* For each hose, we begin searching bridges */
+        for(hose=hose_head; hose; hose=hose->next) {
+                struct device_node* node;       
+                node = (struct device_node *)hose->arch_data;
+                if (!node)
+                        continue;
+                make_one_node_map(node, hose->first_busno);
+        }
+        of_prop_map = get_property(find_path_device("/"), "pci-OF-bus-map", NULL);
+        if (of_prop_map)
+                memcpy(of_prop_map, pci_to_OF_bus_map, pci_bus_count);
+#ifdef DEBUG
+        printk("PCI->OF bus map:\n");
+        for (i=0; i<pci_bus_count; i++) {
+                if (pci_to_OF_bus_map[i] == 0xff)
+                        continue;
+                printk("%d -> %d\n", i, pci_to_OF_bus_map[i]);
+        }
+#endif
+}
+
+typedef int (*pci_OF_scan_iterator)(struct device_node* node, void* data);
+
+static struct device_node*
+scan_OF_pci_childs(struct device_node* node, pci_OF_scan_iterator filter, void* data)
+{
+        struct device_node* sub_node;
+
+        for (; node != 0;node = node->sibling) {
+                unsigned int *class_code;
+        
+                if (filter(node, data))
+                        return node;
+
+                /* For PCI<->PCI bridges or CardBus bridges, we go down
+                 * Note: some OFs create a parent node "multifunc-device" as
+                 * a fake root for all functions of a multi-function device,
+                 * we go down them as well.
+                 */
+                class_code = (unsigned int *) get_property(node, "class-code", NULL);
+                if ((!class_code || ((*class_code >> 8) != PCI_CLASS_BRIDGE_PCI &&
+                        (*class_code >> 8) != PCI_CLASS_BRIDGE_CARDBUS)) &&
+                        strcmp(node->name, "multifunc-device"))
+                        continue;
+                sub_node = scan_OF_pci_childs(node->child, filter, data);
+                if (sub_node)
+                        return sub_node;
+        }
+        return NULL;
+}
+
+static int
+scan_OF_pci_childs_iterator(struct device_node* node, void* data)
+{
+        unsigned int *reg;
+        u8* fdata = (u8*)data;
+        
+        reg = (unsigned int *) get_property(node, "reg", NULL);
+        if (reg && ((reg[0] >> 8) & 0xff) == fdata[1]
+                && ((reg[0] >> 16) & 0xff) == fdata[0])
+                return 1;
+        return 0;
+}
+
+static struct device_node*
+scan_OF_childs_for_device(struct device_node* node, u8 bus, u8 dev_fn)
+{
+        u8 filter_data[2] = {bus, dev_fn};
+
+        return scan_OF_pci_childs(node, scan_OF_pci_childs_iterator, filter_data);
+}
+
+/*
+ * Scans the OF tree for a device node matching a PCI device
+ */
+struct device_node *
+pci_busdev_to_OF_node(struct pci_bus *bus, int devfn)
+{
+        struct pci_controller *hose;
+        struct device_node *node;
+        int busnr;
+
+        if (!have_of)
+                return NULL;
+        
+        /* Lookup the hose */
+        busnr = bus->number;
+        hose = pci_bus_to_hose(busnr);
+        if (!hose)
+                return NULL;
+
+        /* Check it has an OF node associated */
+        node = (struct device_node *) hose->arch_data;
+        if (!node)
+                return NULL;
+
+        /* Fixup bus number according to what OF think it is. */
+#ifdef CONFIG_PPC_PMAC
+        /* The G5 need a special case here. Basically, we don't remap all
+         * busses on it so we don't create the pci-OF-map. However, we do
+         * remap the AGP bus and so have to deal with it. A future better
+         * fix has to be done by making the remapping per-host and always
+         * filling the pci_to_OF map. --BenH
+         */
+        if (_machine == _MACH_Pmac && busnr >= 0xf0)
+                busnr -= 0xf0;
+        else
+#endif
+        if (pci_to_OF_bus_map)
+                busnr = pci_to_OF_bus_map[busnr];
+        if (busnr == 0xff)
+                return NULL;
+        
+        /* Now, lookup childs of the hose */
+        return scan_OF_childs_for_device(node->child, busnr, devfn);
+}
+EXPORT_SYMBOL(pci_busdev_to_OF_node);
+
+struct device_node*
+pci_device_to_OF_node(struct pci_dev *dev)
+{
+        return pci_busdev_to_OF_node(dev->bus, dev->devfn);
+}
+EXPORT_SYMBOL(pci_device_to_OF_node);
+
+/* This routine is meant to be used early during boot, when the
+ * PCI bus numbers have not yet been assigned, and you need to
+ * issue PCI config cycles to an OF device.
+ * It could also be used to "fix" RTAS config cycles if you want
+ * to set pci_assign_all_buses to 1 and still use RTAS for PCI
+ * config cycles.
+ */
+struct pci_controller* pci_find_hose_for_OF_device(struct device_node* node)
+{
+        if (!have_of)
+                return NULL;
+        while(node) {
+                struct pci_controller* hose;
+                for (hose=hose_head;hose;hose=hose->next)
+                        if (hose->arch_data == node)
+                                return hose;
+                node=node->parent;
+        }
+        return NULL;
+}
+
+static int
+find_OF_pci_device_filter(struct device_node* node, void* data)
+{
+        return ((void *)node == data);
+}
+
+/*
+ * Returns the PCI device matching a given OF node
+ */
+int
+pci_device_from_OF_node(struct device_node* node, u8* bus, u8* devfn)
+{
+        unsigned int *reg;
+        struct pci_controller* hose;
+        struct pci_dev* dev = NULL;
+        
+        if (!have_of)
+                return -ENODEV;
+        /* Make sure it's really a PCI device */
+        hose = pci_find_hose_for_OF_device(node);
+        if (!hose || !hose->arch_data)
+                return -ENODEV;
+        if (!scan_OF_pci_childs(((struct device_node*)hose->arch_data)->child,
+                        find_OF_pci_device_filter, (void *)node))
+                return -ENODEV;
+        reg = (unsigned int *) get_property(node, "reg", NULL);
+        if (!reg)
+                return -ENODEV;
+        *bus = (reg[0] >> 16) & 0xff;
+        *devfn = ((reg[0] >> 8) & 0xff);
+
+        /* Ok, here we need some tweak. If we have already renumbered
+         * all busses, we can't rely on the OF bus number any more.
+         * the pci_to_OF_bus_map is not enough as several PCI busses
+         * may match the same OF bus number.
+         */
+        if (!pci_to_OF_bus_map)
+                return 0;
+
+        for_each_pci_dev(dev)
+                if (pci_to_OF_bus_map[dev->bus->number] == *bus &&
+                                dev->devfn == *devfn) {
+                        *bus = dev->bus->number;
+                        pci_dev_put(dev);
+                        return 0;
+                }
+
+        return -ENODEV;
+}
+EXPORT_SYMBOL(pci_device_from_OF_node);
+
+void __init
+pci_process_bridge_OF_ranges(struct pci_controller *hose,
+                           struct device_node *dev, int primary)
+{
+        static unsigned int static_lc_ranges[256] __initdata;
+        unsigned int *dt_ranges, *lc_ranges, *ranges, *prev;
+        unsigned int size;
+        int rlen = 0, orig_rlen;
+        int memno = 0;
+        struct resource *res;
+        int np, na = prom_n_addr_cells(dev);
+        np = na + 5;
+
+        /* First we try to merge ranges to fix a problem with some pmacs
+         * that can have more than 3 ranges, fortunately using contiguous
+         * addresses -- BenH
+         */
+        dt_ranges = (unsigned int *) get_property(dev, "ranges", &rlen);
+        if (!dt_ranges)
+                return;
+        /* Sanity check, though hopefully that never happens */
+        if (rlen > sizeof(static_lc_ranges)) {
+                printk(KERN_WARNING "OF ranges property too large !\n");
+                rlen = sizeof(static_lc_ranges);
+        }
+        lc_ranges = static_lc_ranges;
+        memcpy(lc_ranges, dt_ranges, rlen);
+        orig_rlen = rlen;
+
+        /* Let's work on a copy of the "ranges" property instead of damaging
+         * the device-tree image in memory
+         */
+        ranges = lc_ranges;
+        prev = NULL;
+        while ((rlen -= np * sizeof(unsigned int)) >= 0) {
+                if (prev) {
+                        if (prev[0] == ranges[0] && prev[1] == ranges[1] &&
+                                (prev[2] + prev[na+4]) == ranges[2] &&
+                                (prev[na+2] + prev[na+4]) == ranges[na+2]) {
+                                prev[na+4] += ranges[na+4];
+                                ranges[0] = 0;
+                                ranges += np;
+                                continue;
+                        }
+                }
+                prev = ranges;
+                ranges += np;
+        }
+
+        /*
+         * The ranges property is laid out as an array of elements,
+         * each of which comprises:
+         *   cells 0 - 2:       a PCI address
+         *   cells 3 or 3+4:    a CPU physical address
+         *                      (size depending on dev->n_addr_cells)
+         *   cells 4+5 or 5+6:  the size of the range
+         */
+        ranges = lc_ranges;
+        rlen = orig_rlen;
+        while (ranges && (rlen -= np * sizeof(unsigned int)) >= 0) {
+                res = NULL;
+                size = ranges[na+4];
+                switch ((ranges[0] >> 24) & 0x3) {
+                case 1:         /* I/O space */
+                        if (ranges[2] != 0)
+                                break;
+                        hose->io_base_phys = ranges[na+2];
+                        /* limit I/O space to 16MB */
+                        if (size > 0x01000000)
+                                size = 0x01000000;
+                        hose->io_base_virt = ioremap(ranges[na+2], size);
+                        if (primary)
+                                isa_io_base = (unsigned long) hose->io_base_virt;
+                        res = &hose->io_resource;
+                        res->flags = IORESOURCE_IO;
+                        res->start = ranges[2];
+                        DBG("PCI: IO 0x%lx -> 0x%lx\n",
+                                    res->start, res->start + size - 1);
+                        break;
+                case 2:         /* memory space */
+                        memno = 0;
+                        if (ranges[1] == 0 && ranges[2] == 0
+                            && ranges[na+4] <= (16 << 20)) {
+                                /* 1st 16MB, i.e. ISA memory area */
+                                if (primary)
+                                        isa_mem_base = ranges[na+2];
+                                memno = 1;
+                        }
+                        while (memno < 3 && hose->mem_resources[memno].flags)
+                                ++memno;
+                        if (memno == 0)
+                                hose->pci_mem_offset = ranges[na+2] - ranges[2];
+                        if (memno < 3) {
+                                res = &hose->mem_resources[memno];
+                                res->flags = IORESOURCE_MEM;
+                                if(ranges[0] & 0x40000000)
+                                        res->flags |= IORESOURCE_PREFETCH;
+                                res->start = ranges[na+2];
+                                DBG("PCI: MEM[%d] 0x%lx -> 0x%lx\n", memno,
+                                            res->start, res->start + size - 1);
+                        }
+                        break;
+                }
+                if (res != NULL) {
+                        res->name = dev->full_name;
+                        res->end = res->start + size - 1;
+                        res->parent = NULL;
+                        res->sibling = NULL;
+                        res->child = NULL;
+                }
+                ranges += np;
+        }
+}
+
+/* We create the "pci-OF-bus-map" property now so it appears in the
+ * /proc device tree
+ */
+void __init
+pci_create_OF_bus_map(void)
+{
+        struct property* of_prop;
+        
+        of_prop = (struct property*) alloc_bootmem(sizeof(struct property) + 256);
+        if (of_prop && find_path_device("/")) {
+                memset(of_prop, -1, sizeof(struct property) + 256);
+                of_prop->name = "pci-OF-bus-map";
+                of_prop->length = 256;
+                of_prop->value = (unsigned char *)&of_prop[1];
+                prom_add_property(find_path_device("/"), of_prop);
+        }
+}
+
+static ssize_t pci_show_devspec(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct pci_dev *pdev;
+        struct device_node *np;
+
+        pdev = to_pci_dev (dev);
+        np = pci_device_to_OF_node(pdev);
+        if (np == NULL || np->full_name == NULL)
+                return 0;
+        return sprintf(buf, "%s", np->full_name);
+}
+static DEVICE_ATTR(devspec, S_IRUGO, pci_show_devspec, NULL);
+
+#else /* CONFIG_PPC_OF */
+void pcibios_make_OF_bus_map(void)
+{
+}
+#endif /* CONFIG_PPC_OF */
+
+/* Add sysfs properties */
+void pcibios_add_platform_entries(struct pci_dev *pdev)
+{
+#ifdef CONFIG_PPC_OF
+        device_create_file(&pdev->dev, &dev_attr_devspec);
+#endif /* CONFIG_PPC_OF */
+}
+
+
+#ifdef CONFIG_PPC_PMAC
+/*
+ * This set of routines checks for PCI<->PCI bridges that have closed
+ * IO resources and have child devices. It tries to re-open an IO
+ * window on them.
+ *
+ * This is a _temporary_ fix to workaround a problem with Apple's OF
+ * closing IO windows on P2P bridges when the OF drivers of cards
+ * below this bridge don't claim any IO range (typically ATI or
+ * Adaptec).
+ *
+ * A more complete fix would be to use drivers/pci/setup-bus.c, which
+ * involves a working pcibios_fixup_pbus_ranges(), some more care about
+ * ordering when creating the host bus resources, and maybe a few more
+ * minor tweaks
+ */
+
+/* Initialize bridges with base/limit values we have collected */
+static void __init
+do_update_p2p_io_resource(struct pci_bus *bus, int enable_vga)
+{
+        struct pci_dev *bridge = bus->self;
+        struct pci_controller* hose = (struct pci_controller *)bridge->sysdata;
+        u32 l;
+        u16 w;
+        struct resource res;
+
+        if (bus->resource[0] == NULL)
+                return;
+        res = *(bus->resource[0]);
+
+        DBG("Remapping Bus %d, bridge: %s\n", bus->number, pci_name(bridge));
+        res.start -= ((unsigned long) hose->io_base_virt - isa_io_base);
+        res.end -= ((unsigned long) hose->io_base_virt - isa_io_base);
+        DBG("  IO window: %08lx-%08lx\n", res.start, res.end);
+
+        /* Set up the top and bottom of the PCI I/O segment for this bus. */
+        pci_read_config_dword(bridge, PCI_IO_BASE, &l);
+        l &= 0xffff000f;
+        l |= (res.start >> 8) & 0x00f0;
+        l |= res.end & 0xf000;
+        pci_write_config_dword(bridge, PCI_IO_BASE, l);
+
+        if ((l & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
+                l = (res.start >> 16) | (res.end & 0xffff0000);
+                pci_write_config_dword(bridge, PCI_IO_BASE_UPPER16, l);
+        }
+
+        pci_read_config_word(bridge, PCI_COMMAND, &w);
+        w |= PCI_COMMAND_IO;
+        pci_write_config_word(bridge, PCI_COMMAND, w);
+
+#if 0 /* Enabling this causes XFree 4.2.0 to hang during PCI probe */
+        if (enable_vga) {
+                pci_read_config_word(bridge, PCI_BRIDGE_CONTROL, &w);
+                w |= PCI_BRIDGE_CTL_VGA;
+                pci_write_config_word(bridge, PCI_BRIDGE_CONTROL, w);
+        }
+#endif
+}
+
+/* This function is pretty basic and actually quite broken for the
+ * general case, it's enough for us right now though. It's supposed
+ * to tell us if we need to open an IO range at all or not and what
+ * size.
+ */
+static int __init
+check_for_io_childs(struct pci_bus *bus, struct resource* res, int *found_vga)
+{
+        struct pci_dev *dev;
+        int     i;
+        int     rc = 0;
+
+#define push_end(res, size) do { unsigned long __sz = (size) ; \
+        res->end = ((res->end + __sz) / (__sz + 1)) * (__sz + 1) + __sz; \
+    } while (0)
+
+        list_for_each_entry(dev, &bus->devices, bus_list) {
+                u16 class = dev->class >> 8;
+
+                if (class == PCI_CLASS_DISPLAY_VGA ||
+                    class == PCI_CLASS_NOT_DEFINED_VGA)
+                        *found_vga = 1;
+                if (class >> 8 == PCI_BASE_CLASS_BRIDGE && dev->subordinate)
+                        rc |= check_for_io_childs(dev->subordinate, res, found_vga);
+                if (class == PCI_CLASS_BRIDGE_CARDBUS)
+                        push_end(res, 0xfff);
+
+                for (i=0; i<PCI_NUM_RESOURCES; i++) {
+                        struct resource *r;
+                        unsigned long r_size;
+
+                        if (dev->class >> 8 == PCI_CLASS_BRIDGE_PCI
+                            && i >= PCI_BRIDGE_RESOURCES)
+                                continue;
+                        r = &dev->resource[i];
+                        r_size = r->end - r->start;
+                        if (r_size < 0xfff)
+                                r_size = 0xfff;
+                        if (r->flags & IORESOURCE_IO && (r_size) != 0) {
+                                rc = 1;
+                                push_end(res, r_size);
+                        }
+                }
+        }
+
+        return rc;
+}
+
+/* Here we scan all P2P bridges of a given level that have a closed
+ * IO window. Note that the test for the presence of a VGA card should
+ * be improved to take into account already configured P2P bridges,
+ * currently, we don't see them and might end up configuring 2 bridges
+ * with VGA pass through enabled
+ */
+static void __init
+do_fixup_p2p_level(struct pci_bus *bus)
+{
+        struct pci_bus *b;
+        int i, parent_io;
+        int has_vga = 0;
+
+        for (parent_io=0; parent_io<4; parent_io++)
+                if (bus->resource[parent_io]
+                    && bus->resource[parent_io]->flags & IORESOURCE_IO)
+                        break;
+        if (parent_io >= 4)
+                return;
+
+        list_for_each_entry(b, &bus->children, node) {
+                struct pci_dev *d = b->self;
+                struct pci_controller* hose = (struct pci_controller *)d->sysdata;
+                struct resource *res = b->resource[0];
+                struct resource tmp_res;
+                unsigned long max;
+                int found_vga = 0;
+
+                memset(&tmp_res, 0, sizeof(tmp_res));
+                tmp_res.start = bus->resource[parent_io]->start;
+
+                /* We don't let low addresses go through that closed P2P bridge, well,
+                 * that may not be necessary but I feel safer that way
+                 */
+                if (tmp_res.start == 0)
+                        tmp_res.start = 0x1000;
+        
+                if (!list_empty(&b->devices) && res && res->flags == 0 &&
+                    res != bus->resource[parent_io] &&
+                    (d->class >> 8) == PCI_CLASS_BRIDGE_PCI &&
+                    check_for_io_childs(b, &tmp_res, &found_vga)) {
+                        u8 io_base_lo;
+
+                        printk(KERN_INFO "Fixing up IO bus %s\n", b->name);
+
+                        if (found_vga) {
+                                if (has_vga) {
+                                        printk(KERN_WARNING "Skipping VGA, already active"
+                                            " on bus segment\n");
+                                        found_vga = 0;
+                                } else
+                                        has_vga = 1;
+                        }
+                        pci_read_config_byte(d, PCI_IO_BASE, &io_base_lo);
+
+                        if ((io_base_lo & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32)
+                                max = ((unsigned long) hose->io_base_virt
+                                        - isa_io_base) + 0xffffffff;
+                        else
+                                max = ((unsigned long) hose->io_base_virt
+                                        - isa_io_base) + 0xffff;
+
+                        *res = tmp_res;
+                        res->flags = IORESOURCE_IO;
+                        res->name = b->name;
+                
+                        /* Find a resource in the parent where we can allocate */
+                        for (i = 0 ; i < 4; i++) {
+                                struct resource *r = bus->resource[i];
+                                if (!r)
+                                        continue;
+                                if ((r->flags & IORESOURCE_IO) == 0)
+                                        continue;
+                                DBG("Trying to allocate from %08lx, size %08lx from parent"
+                                    " res %d: %08lx -> %08lx\n",
+                                        res->start, res->end, i, r->start, r->end);
+                        
+                                if (allocate_resource(r, res, res->end + 1, res->start, max,
+                                    res->end + 1, NULL, NULL) < 0) {
+                                        DBG("Failed !\n");
+                                        continue;
+                                }
+                                do_update_p2p_io_resource(b, found_vga);
+                                break;
+                        }
+                }
+                do_fixup_p2p_level(b);
+        }
+}
+
+static void
+pcibios_fixup_p2p_bridges(void)
+{
+        struct pci_bus *b;
+
+        list_for_each_entry(b, &pci_root_buses, node)
+                do_fixup_p2p_level(b);
+}
+
+#endif /* CONFIG_PPC_PMAC */
+
+static int __init
+pcibios_init(void)
+{
+        struct pci_controller *hose;
+        struct pci_bus *bus;
+        int next_busno;
+
+        printk(KERN_INFO "PCI: Probing PCI hardware\n");
+
+        /* Scan all of the recorded PCI controllers.  */
+        for (next_busno = 0, hose = hose_head; hose; hose = hose->next) {
+                if (pci_assign_all_buses)
+                        hose->first_busno = next_busno;
+                hose->last_busno = 0xff;
+                bus = pci_scan_bus(hose->first_busno, hose->ops, hose);
+                hose->last_busno = bus->subordinate;
+                if (pci_assign_all_buses || next_busno <= hose->last_busno)
+                        next_busno = hose->last_busno + pcibios_assign_bus_offset;
+        }
+        pci_bus_count = next_busno;
+
+        /* OpenFirmware based machines need a map of OF bus
+         * numbers vs. kernel bus numbers since we may have to
+         * remap them.
+         */
+        if (pci_assign_all_buses && have_of)
+                pcibios_make_OF_bus_map();
+
+        /* Do machine dependent PCI interrupt routing */
+        if (ppc_md.pci_swizzle && ppc_md.pci_map_irq)
+                pci_fixup_irqs(ppc_md.pci_swizzle, ppc_md.pci_map_irq);
+
+        /* Call machine dependent fixup */
+        if (ppc_md.pcibios_fixup)
+                ppc_md.pcibios_fixup();
+
+        /* Allocate and assign resources */
+        pcibios_allocate_bus_resources(&pci_root_buses);
+        pcibios_allocate_resources(0);
+        pcibios_allocate_resources(1);
+#ifdef CONFIG_PPC_PMAC
+        pcibios_fixup_p2p_bridges();
+#endif /* CONFIG_PPC_PMAC */
+        pcibios_assign_resources();
+
+        /* Call machine dependent post-init code */
+        if (ppc_md.pcibios_after_init)
+                ppc_md.pcibios_after_init();
+
+        return 0;
+}
+
+subsys_initcall(pcibios_init);
+
+unsigned char __init
+common_swizzle(struct pci_dev *dev, unsigned char *pinp)
+{
+        struct pci_controller *hose = dev->sysdata;
+
+        if (dev->bus->number != hose->first_busno) {
+                u8 pin = *pinp;
+                do {
+                        pin = bridge_swizzle(pin, PCI_SLOT(dev->devfn));
+                        /* Move up the chain of bridges. */
+                        dev = dev->bus->self;
+                } while (dev->bus->self);
+                *pinp = pin;
+
+                /* The slot is the idsel of the last bridge. */
+        }
+        return PCI_SLOT(dev->devfn);
+}
+
+unsigned long resource_fixup(struct pci_dev * dev, struct resource * res,
+                             unsigned long start, unsigned long size)
+{
+        return start;
+}
+
+void __init pcibios_fixup_bus(struct pci_bus *bus)
+{
+        struct pci_controller *hose = (struct pci_controller *) bus->sysdata;
+        unsigned long io_offset;
+        struct resource *res;
+        int i;
+
+        io_offset = (unsigned long)hose->io_base_virt - isa_io_base;
+        if (bus->parent == NULL) {
+                /* This is a host bridge - fill in its resources */
+                hose->bus = bus;
+
+                bus->resource[0] = res = &hose->io_resource;
+                if (!res->flags) {
+                        if (io_offset)
+                                printk(KERN_ERR "I/O resource not set for host"
+                                       " bridge %d\n", hose->index);
+                        res->start = 0;
+                        res->end = IO_SPACE_LIMIT;
+                        res->flags = IORESOURCE_IO;
+                }
+                res->start += io_offset;
+                res->end += io_offset;
+
+                for (i = 0; i < 3; ++i) {
+                        res = &hose->mem_resources[i];
+                        if (!res->flags) {
+                                if (i > 0)
+                                        continue;
+                                printk(KERN_ERR "Memory resource not set for "
+                                       "host bridge %d\n", hose->index);
+                                res->start = hose->pci_mem_offset;
+                                res->end = ~0U;
+                                res->flags = IORESOURCE_MEM;
+                        }
+                        bus->resource[i+1] = res;
+                }
+        } else {
+                /* This is a subordinate bridge */
+                pci_read_bridge_bases(bus);
+
+                for (i = 0; i < 4; ++i) {
+                        if ((res = bus->resource[i]) == NULL)
+                                continue;
+                        if (!res->flags)
+                                continue;
+                        if (io_offset && (res->flags & IORESOURCE_IO)) {
+                                res->start += io_offset;
+                                res->end += io_offset;
+                        } else if (hose->pci_mem_offset
+                                   && (res->flags & IORESOURCE_MEM)) {
+                                res->start += hose->pci_mem_offset;
+                                res->end += hose->pci_mem_offset;
+                        }
+                }
+        }
+
+        if (ppc_md.pcibios_fixup_bus)
+                ppc_md.pcibios_fixup_bus(bus);
+}
+
+char __init *pcibios_setup(char *str)
+{
+        return str;
+}
+
+/* the next one is stolen from the alpha port... */
+void __init
+pcibios_update_irq(struct pci_dev *dev, int irq)
+{
+        pci_write_config_byte(dev, PCI_INTERRUPT_LINE, irq);
+        /* XXX FIXME - update OF device tree node interrupt property */
+}
+
+int pcibios_enable_device(struct pci_dev *dev, int mask)
+{
+        u16 cmd, old_cmd;
+        int idx;
+        struct resource *r;
+
+        if (ppc_md.pcibios_enable_device_hook)
+                if (ppc_md.pcibios_enable_device_hook(dev, 0))
+                        return -EINVAL;
+                
+        pci_read_config_word(dev, PCI_COMMAND, &cmd);
+        old_cmd = cmd;
+        for (idx=0; idx<6; idx++) {
+                r = &dev->resource[idx];
+                if (r->flags & IORESOURCE_UNSET) {
+                        printk(KERN_ERR "PCI: Device %s not available because of resource collisions\n", pci_name(dev));
+                        return -EINVAL;
+                }
+                if (r->flags & IORESOURCE_IO)
+                        cmd |= PCI_COMMAND_IO;
+                if (r->flags & IORESOURCE_MEM)
+                        cmd |= PCI_COMMAND_MEMORY;
+        }
+        if (cmd != old_cmd) {
+                printk("PCI: Enabling device %s (%04x -> %04x)\n",
+                       pci_name(dev), old_cmd, cmd);
+                pci_write_config_word(dev, PCI_COMMAND, cmd);
+        }
+        return 0;
+}
+
+struct pci_controller*
+pci_bus_to_hose(int bus)
+{
+        struct pci_controller* hose = hose_head;
+
+        for (; hose; hose = hose->next)
+                if (bus >= hose->first_busno && bus <= hose->last_busno)
+                        return hose;
+        return NULL;
+}
+
+void __iomem *
+pci_bus_io_base(unsigned int bus)
+{
+        struct pci_controller *hose;
+
+        hose = pci_bus_to_hose(bus);
+        if (!hose)
+                return NULL;
+        return hose->io_base_virt;
+}
+
+unsigned long
+pci_bus_io_base_phys(unsigned int bus)
+{
+        struct pci_controller *hose;
+
+        hose = pci_bus_to_hose(bus);
+        if (!hose)
+                return 0;
+        return hose->io_base_phys;
+}
+
+unsigned long
+pci_bus_mem_base_phys(unsigned int bus)
+{
+        struct pci_controller *hose;
+
+        hose = pci_bus_to_hose(bus);
+        if (!hose)
+                return 0;
+        return hose->pci_mem_offset;
+}
+
+unsigned long
+pci_resource_to_bus(struct pci_dev *pdev, struct resource *res)
+{
+        /* Hack alert again ! See comments in chrp_pci.c
+         */
+        struct pci_controller* hose =
+                (struct pci_controller *)pdev->sysdata;
+        if (hose && res->flags & IORESOURCE_MEM)
+                return res->start - hose->pci_mem_offset;
+        /* We may want to do something with IOs here... */
+        return res->start;
+}
+
+
+static struct resource *__pci_mmap_make_offset(struct pci_dev *dev,
+                                               unsigned long *offset,
+                                               enum pci_mmap_state mmap_state)
+{
+        struct pci_controller *hose = pci_bus_to_hose(dev->bus->number);
+        unsigned long io_offset = 0;
+        int i, res_bit;
+
+        if (hose == 0)
+                return NULL;            /* should never happen */
+
+        /* If memory, add on the PCI bridge address offset */
+        if (mmap_state == pci_mmap_mem) {
+                *offset += hose->pci_mem_offset;
+                res_bit = IORESOURCE_MEM;
+        } else {
+                io_offset = hose->io_base_virt - ___IO_BASE;
+                *offset += io_offset;
+                res_bit = IORESOURCE_IO;
+        }
+
+        /*
+         * Check that the offset requested corresponds to one of the
+         * resources of the device.
+         */
+        for (i = 0; i <= PCI_ROM_RESOURCE; i++) {
+                struct resource *rp = &dev->resource[i];
+                int flags = rp->flags;
+
+                /* treat ROM as memory (should be already) */
+                if (i == PCI_ROM_RESOURCE)
+                        flags |= IORESOURCE_MEM;
+
+                /* Active and same type? */
+                if ((flags & res_bit) == 0)
+                        continue;
+
+                /* In the range of this resource? */
+                if (*offset < (rp->start & PAGE_MASK) || *offset > rp->end)
+                        continue;
+
+                /* found it! construct the final physical address */
+                if (mmap_state == pci_mmap_io)
+                        *offset += hose->io_base_phys - io_offset;
+                return rp;
+        }
+
+        return NULL;
+}
+
+/*
+ * Set vm_page_prot of VMA, as appropriate for this architecture, for a pci
+ * device mapping.
+ */
+static pgprot_t __pci_mmap_set_pgprot(struct pci_dev *dev, struct resource *rp,
+                                      pgprot_t protection,
+                                      enum pci_mmap_state mmap_state,
+                                      int write_combine)
+{
+        unsigned long prot = pgprot_val(protection);
+
+        /* Write combine is always 0 on non-memory space mappings. On
+         * memory space, if the user didn't pass 1, we check for a
+         * "prefetchable" resource. This is a bit hackish, but we use
+         * this to workaround the inability of /sysfs to provide a write
+         * combine bit
+         */
+        if (mmap_state != pci_mmap_mem)
+                write_combine = 0;
+        else if (write_combine == 0) {
+                if (rp->flags & IORESOURCE_PREFETCH)
+                        write_combine = 1;
+        }
+
+        /* XXX would be nice to have a way to ask for write-through */
+        prot |= _PAGE_NO_CACHE;
+        if (write_combine)
+                prot &= ~_PAGE_GUARDED;
+        else
+                prot |= _PAGE_GUARDED;
+
+        printk("PCI map for %s:%lx, prot: %lx\n", pci_name(dev), rp->start,
+               prot);
+
+        return __pgprot(prot);
+}
+
+/*
+ * This one is used by /dev/mem and fbdev who have no clue about the
+ * PCI device, it tries to find the PCI device first and calls the
+ * above routine
+ */
+pgprot_t pci_phys_mem_access_prot(struct file *file,
+                                  unsigned long pfn,
+                                  unsigned long size,
+                                  pgprot_t protection)
+{
+        struct pci_dev *pdev = NULL;
+        struct resource *found = NULL;
+        unsigned long prot = pgprot_val(protection);
+        unsigned long offset = pfn << PAGE_SHIFT;
+        int i;
+
+        if (page_is_ram(pfn))
+                return prot;
+
+        prot |= _PAGE_NO_CACHE | _PAGE_GUARDED;
+
+        for_each_pci_dev(pdev) {
+                for (i = 0; i <= PCI_ROM_RESOURCE; i++) {
+                        struct resource *rp = &pdev->resource[i];
+                        int flags = rp->flags;
+
+                        /* Active and same type? */
+                        if ((flags & IORESOURCE_MEM) == 0)
+                                continue;
+                        /* In the range of this resource? */
+                        if (offset < (rp->start & PAGE_MASK) ||
+                            offset > rp->end)
+                                continue;
+                        found = rp;
+                        break;
+                }
+                if (found)
+                        break;
+        }
+        if (found) {
+                if (found->flags & IORESOURCE_PREFETCH)
+                        prot &= ~_PAGE_GUARDED;
+                pci_dev_put(pdev);
+        }
+
+        DBG("non-PCI map for %lx, prot: %lx\n", offset, prot);
+
+        return __pgprot(prot);
+}
+
+
+/*
+ * Perform the actual remap of the pages for a PCI device mapping, as
+ * appropriate for this architecture.  The region in the process to map
+ * is described by vm_start and vm_end members of VMA, the base physical
+ * address is found in vm_pgoff.
+ * The pci device structure is provided so that architectures may make mapping
+ * decisions on a per-device or per-bus basis.
+ *
+ * Returns a negative error code on failure, zero on success.
+ */
+int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
+                        enum pci_mmap_state mmap_state,
+                        int write_combine)
+{
+        unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
+        struct resource *rp;
+        int ret;
+
+        rp = __pci_mmap_make_offset(dev, &offset, mmap_state);
+        if (rp == NULL)
+                return -EINVAL;
+
+        vma->vm_pgoff = offset >> PAGE_SHIFT;
+        vma->vm_flags |= VM_SHM | VM_LOCKED | VM_IO;
+        vma->vm_page_prot = __pci_mmap_set_pgprot(dev, rp,
+                                                  vma->vm_page_prot,
+                                                  mmap_state, write_combine);
+
+        ret = remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
+                               vma->vm_end - vma->vm_start, vma->vm_page_prot);
+
+        return ret;
+}
+
+/* Obsolete functions. Should be removed once the symbios driver
+ * is fixed
+ */
+unsigned long
+phys_to_bus(unsigned long pa)
+{
+        struct pci_controller *hose;
+        int i;
+
+        for (hose = hose_head; hose; hose = hose->next) {
+                for (i = 0; i < 3; ++i) {
+                        if (pa >= hose->mem_resources[i].start
+                            && pa <= hose->mem_resources[i].end) {
+                                /*
+                                 * XXX the hose->pci_mem_offset really
+                                 * only applies to mem_resources[0].
+                                 * We need a way to store an offset for
+                                 * the others.  -- paulus
+                                 */
+                                if (i == 0)
+                                        pa -= hose->pci_mem_offset;
+                                return pa;
+                        }
+                }
+        }
+        /* hmmm, didn't find it */
+        return 0;
+}
+
+unsigned long
+pci_phys_to_bus(unsigned long pa, int busnr)
+{
+        struct pci_controller* hose = pci_bus_to_hose(busnr);
+        if (!hose)
+                return pa;
+        return pa - hose->pci_mem_offset;
+}
+
+unsigned long
+pci_bus_to_phys(unsigned int ba, int busnr)
+{
+        struct pci_controller* hose = pci_bus_to_hose(busnr);
+        if (!hose)
+                return ba;
+        return ba + hose->pci_mem_offset;
+}
+
+/* Provide information on locations of various I/O regions in physical
+ * memory.  Do this on a per-card basis so that we choose the right
+ * root bridge.
+ * Note that the returned IO or memory base is a physical address
+ */
+
+long sys_pciconfig_iobase(long which, unsigned long bus, unsigned long devfn)
+{
+        struct pci_controller* hose;
+        long result = -EOPNOTSUPP;
+
+        /* Argh ! Please forgive me for that hack, but that's the
+         * simplest way to get existing XFree to not lockup on some
+         * G5 machines... So when something asks for bus 0 io base
+         * (bus 0 is HT root), we return the AGP one instead.
+         */
+#ifdef CONFIG_PPC_PMAC
+        if (_machine == _MACH_Pmac && machine_is_compatible("MacRISC4"))
+                if (bus == 0)
+                        bus = 0xf0;
+#endif /* CONFIG_PPC_PMAC */
+
+        hose = pci_bus_to_hose(bus);
+        if (!hose)
+                return -ENODEV;
+
+        switch (which) {
+        case IOBASE_BRIDGE_NUMBER:
+                return (long)hose->first_busno;
+        case IOBASE_MEMORY:
+                return (long)hose->pci_mem_offset;
+        case IOBASE_IO:
+                return (long)hose->io_base_phys;
+        case IOBASE_ISA_IO:
+                return (long)isa_io_base;
+        case IOBASE_ISA_MEM:
+                return (long)isa_mem_base;
+        }
+
+        return result;
+}
+
+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_hose(dev->bus->number);
+        unsigned long offset = 0;
+
+        if (hose == NULL)
+                return;
+
+        if (rsrc->flags & IORESOURCE_IO)
+                offset = ___IO_BASE - hose->io_base_virt + hose->io_base_phys;
+
+        *start = rsrc->start + offset;
+        *end = rsrc->end + offset;
+}
+
+void __init
+pci_init_resource(struct resource *res, unsigned long start, unsigned long end,
+                  int flags, char *name)
+{
+        res->start = start;
+        res->end = end;
+        res->flags = flags;
+        res->name = name;
+        res->parent = NULL;
+        res->sibling = NULL;
+        res->child = NULL;
+}
+
+void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long max)
+{
+        unsigned long start = pci_resource_start(dev, bar);
+        unsigned long len = pci_resource_len(dev, bar);
+        unsigned long flags = pci_resource_flags(dev, bar);
+
+        if (!len)
+                return NULL;
+        if (max && len > max)
+                len = max;
+        if (flags & IORESOURCE_IO)
+                return ioport_map(start, len);
+        if (flags & IORESOURCE_MEM)
+                /* Not checking IORESOURCE_CACHEABLE because PPC does
+                 * not currently distinguish between ioremap and
+                 * ioremap_nocache.
+                 */
+                return ioremap(start, len);
+        /* What? */
+        return NULL;
+}
+
+void pci_iounmap(struct pci_dev *dev, void __iomem *addr)
+{
+        /* Nothing to do */
+}
+EXPORT_SYMBOL(pci_iomap);
+EXPORT_SYMBOL(pci_iounmap);
+
+unsigned long pci_address_to_pio(phys_addr_t address)
+{
+        struct pci_controller* hose = hose_head;
+
+        for (; hose; hose = hose->next) {
+                unsigned int size = hose->io_resource.end -
+                        hose->io_resource.start + 1;
+                if (address >= hose->io_base_phys &&
+                    address < (hose->io_base_phys + size)) {
+                        unsigned long base =
+                                (unsigned long)hose->io_base_virt - _IO_BASE;
+                        return base + (address - hose->io_base_phys);
+                }
+        }
+        return (unsigned int)-1;
+}
+EXPORT_SYMBOL(pci_address_to_pio);
+
+/*
+ * Null PCI config access functions, for the case when we can't
+ * find a hose.
+ */
+#define NULL_PCI_OP(rw, size, type)                                     \
+static int                                                              \
+null_##rw##_config_##size(struct pci_dev *dev, int offset, type val)    \
+{                                                                       \
+        return PCIBIOS_DEVICE_NOT_FOUND;                                \
+}
+
+static int
+null_read_config(struct pci_bus *bus, unsigned int devfn, int offset,
+                 int len, u32 *val)
+{
+        return PCIBIOS_DEVICE_NOT_FOUND;
+}
+
+static int
+null_write_config(struct pci_bus *bus, unsigned int devfn, int offset,
+                  int len, u32 val)
+{
+        return PCIBIOS_DEVICE_NOT_FOUND;
+}
+
+static struct pci_ops null_pci_ops =
+{
+        null_read_config,
+        null_write_config
+};
+
+/*
+ * These functions are used early on before PCI scanning is done
+ * and all of the pci_dev and pci_bus structures have been created.
+ */
+static struct pci_bus *
+fake_pci_bus(struct pci_controller *hose, int busnr)
+{
+        static struct pci_bus bus;
+
+        if (hose == 0) {
+                hose = pci_bus_to_hose(busnr);
+                if (hose == 0)
+                        printk(KERN_ERR "Can't find hose for PCI bus %d!\n", busnr);
+        }
+        bus.number = busnr;
+        bus.sysdata = hose;
+        bus.ops = hose? hose->ops: &null_pci_ops;
+        return &bus;
+}
+
+#define EARLY_PCI_OP(rw, size, type)                                    \
+int early_##rw##_config_##size(struct pci_controller *hose, int bus,    \
+                               int devfn, int offset, type value)       \
+{                                                                       \
+        return pci_bus_##rw##_config_##size(fake_pci_bus(hose, bus),    \
+                                            devfn, offset, value);      \
+}
+
+EARLY_PCI_OP(read, byte, u8 *)
+EARLY_PCI_OP(read, word, u16 *)
+EARLY_PCI_OP(read, dword, u32 *)
+EARLY_PCI_OP(write, byte, u8)
+EARLY_PCI_OP(write, word, u16)
+EARLY_PCI_OP(write, dword, u32)
diff --git a/arch/powerpc/kernel/ppc_ksyms.c b/arch/powerpc/kernel/ppc_ksyms.c
index 16d9a904f3cb..d9a459c144d8 100644
--- a/arch/powerpc/kernel/ppc_ksyms.c
+++ b/arch/powerpc/kernel/ppc_ksyms.c
@@ -230,8 +230,7 @@ EXPORT_SYMBOL(__down_interruptible);
 EXPORT_SYMBOL(cpm_install_handler);
 EXPORT_SYMBOL(cpm_free_handler);
 #endif /* CONFIG_8xx */
-#if defined(CONFIG_8xx) || defined(CONFIG_40x) || defined(CONFIG_85xx) ||\
-        defined(CONFIG_83xx)
+#if defined(CONFIG_8xx) || defined(CONFIG_40x)
 EXPORT_SYMBOL(__res);
 #endif
 
diff --git a/arch/powerpc/kernel/prom.c b/arch/powerpc/kernel/prom.c
index 02e2115323e4..d50c8df0183e 100644
--- a/arch/powerpc/kernel/prom.c
+++ b/arch/powerpc/kernel/prom.c
@@ -1627,6 +1627,11 @@ static void of_node_release(struct kref *kref)
                 kfree(prop->value);
                 kfree(prop);
                 prop = next;
+
+                if (!prop) {
+                        prop = node->deadprops;
+                        node->deadprops = NULL;
+                }
         }
         kfree(node->intrs);
         kfree(node->full_name);
@@ -1774,22 +1779,32 @@ static int __init prom_reconfig_setup(void)
 __initcall(prom_reconfig_setup);
 #endif
 
-/*
- * Find a property with a given name for a given node
- * and return the value.
- */
-unsigned char *get_property(struct device_node *np, const char *name,
-                            int *lenp)
+struct property *of_find_property(struct device_node *np, const char *name,
+                                  int *lenp)
 {
         struct property *pp;
 
+        read_lock(&devtree_lock);
         for (pp = np->properties; pp != 0; pp = pp->next)
                 if (strcmp(pp->name, name) == 0) {
                         if (lenp != 0)
                                 *lenp = pp->length;
-                        return pp->value;
+                        break;
                 }
-        return NULL;
+        read_unlock(&devtree_lock);
+
+        return pp;
+}
+
+/*
+ * Find a property with a given name for a given node
+ * and return the value.
+ */
+unsigned char *get_property(struct device_node *np, const char *name,
+                            int *lenp)
+{
+        struct property *pp = of_find_property(np,name,lenp);
+        return pp ? pp->value : NULL;
 }
 EXPORT_SYMBOL(get_property);
 
@@ -1823,4 +1838,82 @@ int prom_add_property(struct device_node* np, struct property* prop)
         return 0;
 }
 
+/*
+ * Remove a property from a node.  Note that we don't actually
+ * remove it, since we have given out who-knows-how-many pointers
+ * to the data using get-property.  Instead we just move the property
+ * to the "dead properties" list, so it won't be found any more.
+ */
+int prom_remove_property(struct device_node *np, struct property *prop)
+{
+        struct property **next;
+        int found = 0;
 
+        write_lock(&devtree_lock);
+        next = &np->properties;
+        while (*next) {
+                if (*next == prop) {
+                        /* found the node */
+                        *next = prop->next;
+                        prop->next = np->deadprops;
+                        np->deadprops = prop;
+                        found = 1;
+                        break;
+                }
+                next = &(*next)->next;
+        }
+        write_unlock(&devtree_lock);
+
+        if (!found)
+                return -ENODEV;
+
+#ifdef CONFIG_PROC_DEVICETREE
+        /* try to remove the proc node as well */
+        if (np->pde)
+                proc_device_tree_remove_prop(np->pde, prop);
+#endif /* CONFIG_PROC_DEVICETREE */
+
+        return 0;
+}
+
+/*
+ * Update a property in a node.  Note that we don't actually
+ * remove it, since we have given out who-knows-how-many pointers
+ * to the data using get-property.  Instead we just move the property
+ * to the "dead properties" list, and add the new property to the
+ * property list
+ */
+int prom_update_property(struct device_node *np,
+                         struct property *newprop,
+                         struct property *oldprop)
+{
+        struct property **next;
+        int found = 0;
+
+        write_lock(&devtree_lock);
+        next = &np->properties;
+        while (*next) {
+                if (*next == oldprop) {
+                        /* found the node */
+                        newprop->next = oldprop->next;
+                        *next = newprop;
+                        oldprop->next = np->deadprops;
+                        np->deadprops = oldprop;
+                        found = 1;
+                        break;
+                }
+                next = &(*next)->next;
+        }
+        write_unlock(&devtree_lock);
+
+        if (!found)
+                return -ENODEV;
+
+#ifdef CONFIG_PROC_DEVICETREE
+        /* try to add to proc as well if it was initialized */
+        if (np->pde)
+                proc_device_tree_update_prop(np->pde, newprop, oldprop);
+#endif /* CONFIG_PROC_DEVICETREE */
+
+        return 0;
+}
diff --git a/arch/powerpc/kernel/prom_init.c b/arch/powerpc/kernel/prom_init.c
index d963a12ec640..7881ec96ef11 100644
--- a/arch/powerpc/kernel/prom_init.c
+++ b/arch/powerpc/kernel/prom_init.c
@@ -605,7 +605,8 @@ static void __init early_cmdline_parse(void)
         opt = strstr(RELOC(prom_cmd_line), RELOC("crashkernel="));
         if (opt) {
                 opt += 12;
-                RELOC(prom_crashk_size) = prom_memparse(opt, &opt);
+                RELOC(prom_crashk_size) = 
+                        prom_memparse(opt, (const char **)&opt);
 
                 if (ALIGN(RELOC(prom_crashk_size), 0x1000000) !=
                         RELOC(prom_crashk_size)) {
diff --git a/arch/powerpc/kernel/prom_parse.c b/arch/powerpc/kernel/prom_parse.c
index 309ae1d5fa77..a8099c806150 100644
--- a/arch/powerpc/kernel/prom_parse.c
+++ b/arch/powerpc/kernel/prom_parse.c
@@ -113,7 +113,8 @@ static unsigned int of_bus_default_get_flags(u32 *addr)
 
 static int of_bus_pci_match(struct device_node *np)
 {
-        return !strcmp(np->type, "pci");
+        /* "vci" is for the /chaos bridge on 1st-gen PCI powermacs */
+        return !strcmp(np->type, "pci") || !strcmp(np->type, "vci");
 }
 
 static void of_bus_pci_count_cells(struct device_node *np,
diff --git a/arch/powerpc/kernel/rtas.c b/arch/powerpc/kernel/rtas.c
index 4b9cfe4637b1..7fe4a5c944c9 100644
--- a/arch/powerpc/kernel/rtas.c
+++ b/arch/powerpc/kernel/rtas.c
@@ -36,6 +36,11 @@ struct rtas_t rtas = {
         .lock = SPIN_LOCK_UNLOCKED
 };
 
+struct rtas_suspend_me_data {
+        long waiting;
+        struct rtas_args *args;
+};
+
 EXPORT_SYMBOL(rtas);
 
 DEFINE_SPINLOCK(rtas_data_buf_lock);
@@ -556,6 +561,80 @@ void rtas_os_term(char *str)
         } while (status == RTAS_BUSY);
 }
 
+static int ibm_suspend_me_token = RTAS_UNKNOWN_SERVICE;
+#ifdef CONFIG_PPC_PSERIES
+static void rtas_percpu_suspend_me(void *info)
+{
+        long rc;
+        long flags;
+        struct rtas_suspend_me_data *data =
+                (struct rtas_suspend_me_data *)info;
+
+        /*
+         * We use "waiting" to indicate our state.  As long
+         * as it is >0, we are still trying to all join up.
+         * If it goes to 0, we have successfully joined up and
+         * one thread got H_Continue.  If any error happens,
+         * we set it to <0.
+         */
+        local_irq_save(flags);
+        do {
+                rc = plpar_hcall_norets(H_JOIN);
+                smp_rmb();
+        } while (rc == H_Success && data->waiting > 0);
+        if (rc == H_Success)
+                goto out;
+
+        if (rc == H_Continue) {
+                data->waiting = 0;
+                rtas_call(ibm_suspend_me_token, 0, 1,
+                          data->args->args);
+        } else {
+                data->waiting = -EBUSY;
+                printk(KERN_ERR "Error on H_Join hypervisor call\n");
+        }
+
+out:
+        /* before we restore interrupts, make sure we don't
+         * generate a spurious soft lockup errors
+         */
+        touch_softlockup_watchdog();
+        local_irq_restore(flags);
+        return;
+}
+
+static int rtas_ibm_suspend_me(struct rtas_args *args)
+{
+        int i;
+
+        struct rtas_suspend_me_data data;
+
+        data.waiting = 1;
+        data.args = args;
+
+        /* Call function on all CPUs.  One of us will make the
+         * rtas call
+         */
+        if (on_each_cpu(rtas_percpu_suspend_me, &data, 1, 0))
+                data.waiting = -EINVAL;
+
+        if (data.waiting != 0)
+                printk(KERN_ERR "Error doing global join\n");
+
+        /* Prod each CPU.  This won't hurt, and will wake
+         * anyone we successfully put to sleep with H_Join
+         */
+        for_each_cpu(i)
+                plpar_hcall_norets(H_PROD, i);
+
+        return data.waiting;
+}
+#else /* CONFIG_PPC_PSERIES */
+static int rtas_ibm_suspend_me(struct rtas_args *args)
+{
+        return -ENOSYS;
+}
+#endif
 
 asmlinkage int ppc_rtas(struct rtas_args __user *uargs)
 {
@@ -563,6 +642,7 @@ asmlinkage int ppc_rtas(struct rtas_args __user *uargs)
         unsigned long flags;
         char *buff_copy, *errbuf = NULL;
         int nargs;
+        int rc;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
@@ -581,6 +661,17 @@ asmlinkage int ppc_rtas(struct rtas_args __user *uargs)
                            nargs * sizeof(rtas_arg_t)) != 0)
                 return -EFAULT;
 
+        if (args.token == RTAS_UNKNOWN_SERVICE)
+                return -EINVAL;
+
+        /* Need to handle ibm,suspend_me call specially */
+        if (args.token == ibm_suspend_me_token) {
+                rc = rtas_ibm_suspend_me(&args);
+                if (rc)
+                        return rc;
+                goto copy_return;
+        }
+
         buff_copy = get_errorlog_buffer();
 
         spin_lock_irqsave(&rtas.lock, flags);
@@ -604,6 +695,7 @@ asmlinkage int ppc_rtas(struct rtas_args __user *uargs)
                 kfree(buff_copy);
         }
 
+ copy_return:
         /* Copy out args. */
         if (copy_to_user(uargs->args + nargs,
                          args.args + nargs,
@@ -675,8 +767,10 @@ void __init rtas_initialize(void)
          * the stop-self token if any
          */
 #ifdef CONFIG_PPC64
-        if (_machine == PLATFORM_PSERIES_LPAR)
+        if (_machine == PLATFORM_PSERIES_LPAR) {
                 rtas_region = min(lmb.rmo_size, RTAS_INSTANTIATE_MAX);
+                ibm_suspend_me_token = rtas_token("ibm,suspend-me");
+        }
 #endif
         rtas_rmo_buf = lmb_alloc_base(RTAS_RMOBUF_MAX, PAGE_SIZE, rtas_region);
 
diff --git a/arch/powerpc/kernel/setup-common.c b/arch/powerpc/kernel/setup-common.c
index d5c52fae023a..be12041c0fc5 100644
--- a/arch/powerpc/kernel/setup-common.c
+++ b/arch/powerpc/kernel/setup-common.c
@@ -100,7 +100,8 @@ void machine_shutdown(void)
 void machine_restart(char *cmd)
 {
         machine_shutdown();
-        ppc_md.restart(cmd);
+        if (ppc_md.restart)
+                ppc_md.restart(cmd);
 #ifdef CONFIG_SMP
         smp_send_stop();
 #endif
@@ -112,7 +113,8 @@ void machine_restart(char *cmd)
 void machine_power_off(void)
 {
         machine_shutdown();
-        ppc_md.power_off();
+        if (ppc_md.power_off)
+                ppc_md.power_off();
 #ifdef CONFIG_SMP
         smp_send_stop();
 #endif
@@ -129,7 +131,8 @@ EXPORT_SYMBOL_GPL(pm_power_off);
 void machine_halt(void)
 {
         machine_shutdown();
-        ppc_md.halt();
+        if (ppc_md.halt)
+                ppc_md.halt();
 #ifdef CONFIG_SMP
         smp_send_stop();
 #endif
diff --git a/arch/powerpc/kernel/time.c b/arch/powerpc/kernel/time.c
index 56f50e91bddb..c4a294d657b9 100644
--- a/arch/powerpc/kernel/time.c
+++ b/arch/powerpc/kernel/time.c
@@ -431,7 +431,7 @@ void timer_interrupt(struct pt_regs * regs)
         profile_tick(CPU_PROFILING, regs);
 
 #ifdef CONFIG_PPC_ISERIES
-        get_paca()->lppaca.int_dword.fields.decr_int = 0;
+        get_lppaca()->int_dword.fields.decr_int = 0;
 #endif
 
         while ((ticks = tb_ticks_since(per_cpu(last_jiffy, cpu)))
diff --git a/arch/powerpc/kernel/vio.c b/arch/powerpc/kernel/vio.c
index 13c41495fe06..13c655ba2841 100644
--- a/arch/powerpc/kernel/vio.c
+++ b/arch/powerpc/kernel/vio.c
@@ -76,7 +76,7 @@ static void vio_bus_shutdown(struct device *dev)
         struct vio_dev *viodev = to_vio_dev(dev);
         struct vio_driver *viodrv = to_vio_driver(dev->driver);
 
-        if (viodrv->shutdown)
+        if (dev->driver && viodrv->shutdown)
                 viodrv->shutdown(viodev);
 }
 
@@ -91,9 +91,6 @@ int vio_register_driver(struct vio_driver *viodrv)
 
         /* fill in 'struct driver' fields */
         viodrv->driver.bus = &vio_bus_type;
-        viodrv->driver.probe = vio_bus_probe;
-        viodrv->driver.remove = vio_bus_remove;
-        viodrv->driver.shutdown = vio_bus_shutdown;
 
         return driver_register(&viodrv->driver);
 }
@@ -295,4 +292,7 @@ struct bus_type vio_bus_type = {
         .name = "vio",
         .uevent = vio_hotplug,
         .match = vio_bus_match,
+        .probe = vio_bus_probe,
+        .remove = vio_bus_remove,
+        .shutdown = vio_bus_shutdown,
 };
diff --git a/arch/powerpc/lib/locks.c b/arch/powerpc/lib/locks.c
index 35bd03c41dd1..8362fa272ca5 100644
--- a/arch/powerpc/lib/locks.c
+++ b/arch/powerpc/lib/locks.c
@@ -28,15 +28,13 @@
 void __spin_yield(raw_spinlock_t *lock)
 {
         unsigned int lock_value, holder_cpu, yield_count;
-        struct paca_struct *holder_paca;
 
         lock_value = lock->slock;
         if (lock_value == 0)
                 return;
         holder_cpu = lock_value & 0xffff;
         BUG_ON(holder_cpu >= NR_CPUS);
-        holder_paca = &paca[holder_cpu];
-        yield_count = holder_paca->lppaca.yield_count;
+        yield_count = lppaca[holder_cpu].yield_count;
         if ((yield_count & 1) == 0)
                 return;         /* virtual cpu is currently running */
         rmb();
@@ -60,15 +58,13 @@ void __rw_yield(raw_rwlock_t *rw)
 {
         int lock_value;
         unsigned int holder_cpu, yield_count;
-        struct paca_struct *holder_paca;
 
         lock_value = rw->lock;
         if (lock_value >= 0)
                 return;         /* no write lock at present */
         holder_cpu = lock_value & 0xffff;
         BUG_ON(holder_cpu >= NR_CPUS);
-        holder_paca = &paca[holder_cpu];
-        yield_count = holder_paca->lppaca.yield_count;
+        yield_count = lppaca[holder_cpu].yield_count;
         if ((yield_count & 1) == 0)
                 return;         /* virtual cpu is currently running */
         rmb();
diff --git a/arch/powerpc/oprofile/common.c b/arch/powerpc/oprofile/common.c
index 71615eb70b2b..cc2535be3a73 100644
--- a/arch/powerpc/oprofile/common.c
+++ b/arch/powerpc/oprofile/common.c
@@ -140,19 +140,19 @@ int __init oprofile_arch_init(struct oprofile_operations *ops)
 
         switch (cur_cpu_spec->oprofile_type) {
 #ifdef CONFIG_PPC64
-                case RS64:
+                case PPC_OPROFILE_RS64:
                         model = &op_model_rs64;
                         break;
-                case POWER4:
+                case PPC_OPROFILE_POWER4:
                         model = &op_model_power4;
                         break;
 #else
-                case G4:
+                case PPC_OPROFILE_G4:
                         model = &op_model_7450;
                         break;
 #endif
 #ifdef CONFIG_FSL_BOOKE
-                case BOOKE:
+                case PPC_OPROFILE_BOOKE:
                         model = &op_model_fsl_booke;
                         break;
 #endif
diff --git a/arch/powerpc/platforms/83xx/Kconfig b/arch/powerpc/platforms/83xx/Kconfig
index b20812d460e6..7675e675dce1 100644
--- a/arch/powerpc/platforms/83xx/Kconfig
+++ b/arch/powerpc/platforms/83xx/Kconfig
@@ -7,6 +7,7 @@ choice
 
 config MPC834x_SYS
         bool "Freescale MPC834x SYS"
+        select DEFAULT_UIMAGE
         help
           This option enables support for the MPC 834x SYS evaluation board.
 
diff --git a/arch/powerpc/platforms/83xx/mpc834x_sys.c b/arch/powerpc/platforms/83xx/mpc834x_sys.c
new file mode 100644
index 000000000000..2098dd05a773
--- /dev/null
+++ b/arch/powerpc/platforms/83xx/mpc834x_sys.c
@@ -0,0 +1,243 @@
+/*
+ * arch/powerpc/platforms/83xx/mpc834x_sys.c
+ *
+ * MPC834x SYS board specific routines
+ *
+ * Maintainer: Kumar Gala <galak@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.
+ */
+
+#include <linux/config.h>
+#include <linux/stddef.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/reboot.h>
+#include <linux/pci.h>
+#include <linux/kdev_t.h>
+#include <linux/major.h>
+#include <linux/console.h>
+#include <linux/delay.h>
+#include <linux/seq_file.h>
+#include <linux/root_dev.h>
+#include <linux/module.h>
+#include <linux/fsl_devices.h>
+
+#include <asm/system.h>
+#include <asm/pgtable.h>
+#include <asm/page.h>
+#include <asm/atomic.h>
+#include <asm/time.h>
+#include <asm/io.h>
+#include <asm/machdep.h>
+#include <asm/ipic.h>
+#include <asm/bootinfo.h>
+#include <asm/pci-bridge.h>
+#include <asm/mpc83xx.h>
+#include <asm/irq.h>
+#include <mm/mmu_decl.h>
+#include <asm/prom.h>
+#include <asm/udbg.h>
+#include <sysdev/fsl_soc.h>
+
+#include "mpc83xx.h"
+
+#ifndef CONFIG_PCI
+unsigned long isa_io_base = 0;
+unsigned long isa_mem_base = 0;
+#endif
+
+#ifdef CONFIG_PCI
+extern int mpc83xx_pci2_busno;
+
+static int
+mpc83xx_map_irq(struct pci_dev *dev, unsigned char idsel, unsigned char pin)
+{
+        static char pci_irq_table[][4] =
+            /*
+             *      PCI IDSEL/INTPIN->INTLINE
+             *       A      B      C      D
+             */
+        {
+                {PIRQA, PIRQB, PIRQC, PIRQD},   /* idsel 0x11 */
+                {PIRQC, PIRQD, PIRQA, PIRQB},   /* idsel 0x12 */
+                {PIRQD, PIRQA, PIRQB, PIRQC},   /* idsel 0x13 */
+                {0, 0, 0, 0},
+                {PIRQA, PIRQB, PIRQC, PIRQD},   /* idsel 0x15 */
+                {PIRQD, PIRQA, PIRQB, PIRQC},   /* idsel 0x16 */
+                {PIRQC, PIRQD, PIRQA, PIRQB},   /* idsel 0x17 */
+                {PIRQB, PIRQC, PIRQD, PIRQA},   /* idsel 0x18 */
+                {0, 0, 0, 0},                   /* idsel 0x19 */
+                {0, 0, 0, 0},                   /* idsel 0x20 */
+        };
+
+        const long min_idsel = 0x11, max_idsel = 0x20, irqs_per_slot = 4;
+        return PCI_IRQ_TABLE_LOOKUP;
+}
+
+static int
+mpc83xx_exclude_device(u_char bus, u_char devfn)
+{
+        if (bus == 0 && PCI_SLOT(devfn) == 0)
+                return PCIBIOS_DEVICE_NOT_FOUND;
+        if (mpc83xx_pci2_busno)
+                if (bus == (mpc83xx_pci2_busno) && PCI_SLOT(devfn) == 0)
+                        return PCIBIOS_DEVICE_NOT_FOUND;
+        return PCIBIOS_SUCCESSFUL;
+}
+#endif /* CONFIG_PCI */
+
+/* ************************************************************************
+ *
+ * Setup the architecture
+ *
+ */
+static void __init
+mpc834x_sys_setup_arch(void)
+{
+        struct device_node *np;
+
+        if (ppc_md.progress)
+                ppc_md.progress("mpc834x_sys_setup_arch()", 0);
+
+        np = of_find_node_by_type(NULL, "cpu");
+        if (np != 0) {
+                unsigned int *fp = (int *) get_property(np, "clock-frequency", NULL);
+                if (fp != 0)
+                        loops_per_jiffy = *fp / HZ;
+                else
+                        loops_per_jiffy = 50000000 / HZ;
+                of_node_put(np);
+        }
+
+#ifdef CONFIG_PCI
+        for (np = NULL; (np = of_find_node_by_type(np, "pci")) != NULL;)
+                add_bridge(np);
+
+        ppc_md.pci_swizzle = common_swizzle;
+        ppc_md.pci_map_irq = mpc83xx_map_irq;
+        ppc_md.pci_exclude_device = mpc83xx_exclude_device;
+#endif
+
+#ifdef  CONFIG_ROOT_NFS
+                ROOT_DEV = Root_NFS;
+#else
+                ROOT_DEV = Root_HDA1;
+#endif
+}
+
+void __init
+mpc834x_sys_init_IRQ(void)
+{
+        u8 senses[8] = {
+                0,                      /* EXT 0 */
+                IRQ_SENSE_LEVEL,        /* EXT 1 */
+                IRQ_SENSE_LEVEL,        /* EXT 2 */
+                0,                      /* EXT 3 */
+#ifdef CONFIG_PCI
+                IRQ_SENSE_LEVEL,        /* EXT 4 */
+                IRQ_SENSE_LEVEL,        /* EXT 5 */
+                IRQ_SENSE_LEVEL,        /* EXT 6 */
+                IRQ_SENSE_LEVEL,        /* EXT 7 */
+#else
+                0,                      /* EXT 4 */
+                0,                      /* EXT 5 */
+                0,                      /* EXT 6 */
+                0,                      /* EXT 7 */
+#endif
+        };
+
+        ipic_init(get_immrbase() + 0x00700, 0, 0, senses, 8);
+
+        /* Initialize the default interrupt mapping priorities,
+         * in case the boot rom changed something on us.
+         */
+        ipic_set_default_priority();
+}
+
+#if defined(CONFIG_I2C_MPC) && defined(CONFIG_SENSORS_DS1374)
+extern ulong    ds1374_get_rtc_time(void);
+extern int      ds1374_set_rtc_time(ulong);
+
+static int __init
+mpc834x_rtc_hookup(void)
+{
+        struct timespec tv;
+
+        ppc_md.get_rtc_time = ds1374_get_rtc_time;
+        ppc_md.set_rtc_time = ds1374_set_rtc_time;
+
+        tv.tv_nsec = 0;
+        tv.tv_sec = (ppc_md.get_rtc_time)();
+        do_settimeofday(&tv);
+
+        return 0;
+}
+late_initcall(mpc834x_rtc_hookup);
+#endif
+
+static void
+mpc83xx_restart(char *cmd)
+{
+#define RST_OFFSET      0x00000900
+#define RST_PROT_REG    0x00000018
+#define RST_CTRL_REG    0x0000001c
+        __be32 __iomem *reg;
+
+        // map reset register space
+        reg = ioremap(get_immrbase() + 0x900, 0xff);
+
+        local_irq_disable();
+
+        /* enable software reset "RSTE" */
+        out_be32(reg + (RST_PROT_REG >> 2), 0x52535445);
+
+        /* set software hard reset */
+        out_be32(reg + (RST_CTRL_REG >> 2), 0x52535445);
+        for(;;);
+}
+
+static long __init
+mpc83xx_time_init(void)
+{
+#define SPCR_OFFSET     0x00000110
+#define SPCR_TBEN       0x00400000
+        __be32 __iomem *spcr = ioremap(get_immrbase() + SPCR_OFFSET, 4);
+        __be32 tmp;
+
+        tmp = in_be32(spcr);
+        out_be32(spcr, tmp|SPCR_TBEN);
+
+        iounmap(spcr);
+
+        return 0;
+}
+void __init
+platform_init(void)
+{
+        /* setup the PowerPC module struct */
+        ppc_md.setup_arch = mpc834x_sys_setup_arch;
+
+        ppc_md.init_IRQ = mpc834x_sys_init_IRQ;
+        ppc_md.get_irq = ipic_get_irq;
+
+        ppc_md.restart = mpc83xx_restart;
+
+        ppc_md.time_init = mpc83xx_time_init;
+        ppc_md.set_rtc_time = NULL;
+        ppc_md.get_rtc_time = NULL;
+        ppc_md.calibrate_decr = generic_calibrate_decr;
+
+        ppc_md.progress = udbg_progress;
+
+        if (ppc_md.progress)
+                ppc_md.progress("mpc834x_sys_init(): exit", 0);
+
+        return;
+}
+
+
diff --git a/arch/powerpc/platforms/83xx/mpc834x_sys.h b/arch/powerpc/platforms/83xx/mpc834x_sys.h
new file mode 100644
index 000000000000..e4ca39f6a862
--- /dev/null
+++ b/arch/powerpc/platforms/83xx/mpc834x_sys.h
@@ -0,0 +1,23 @@
+/*
+ * arch/powerppc/platforms/83xx/mpc834x_sys.h
+ *
+ * MPC834X SYS common board definitions
+ *
+ * Maintainer: Kumar Gala <galak@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.
+ *
+ */
+
+#ifndef __MACH_MPC83XX_SYS_H__
+#define __MACH_MPC83XX_SYS_H__
+
+#define PIRQA   MPC83xx_IRQ_EXT4
+#define PIRQB   MPC83xx_IRQ_EXT5
+#define PIRQC   MPC83xx_IRQ_EXT6
+#define PIRQD   MPC83xx_IRQ_EXT7
+
+#endif                /* __MACH_MPC83XX_SYS_H__ */
diff --git a/arch/powerpc/platforms/83xx/mpc83xx.h b/arch/powerpc/platforms/83xx/mpc83xx.h
new file mode 100644
index 000000000000..ce9e66abef24
--- /dev/null
+++ b/arch/powerpc/platforms/83xx/mpc83xx.h
@@ -0,0 +1,14 @@
+#ifndef __MPC83XX_H__
+#define __MPC83XX_H__
+
+#include <linux/init.h>
+#include <linux/device.h>
+
+/*
+ * Declaration for the various functions exported by the
+ * mpc83xx_* files. Mostly for use by mpc83xx_setup
+ */
+
+extern int add_bridge(struct device_node *dev);
+
+#endif /* __MPC83XX_H__ */
diff --git a/arch/powerpc/platforms/83xx/pci.c b/arch/powerpc/platforms/83xx/pci.c
new file mode 100644
index 000000000000..469cdacc5bd4
--- /dev/null
+++ b/arch/powerpc/platforms/83xx/pci.c
@@ -0,0 +1,99 @@
+/*
+ * FSL SoC setup code
+ *
+ * Maintained by Kumar Gala (see MAINTAINERS for contact information)
+ *
+ * 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 <linux/config.h>
+#include <linux/stddef.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <linux/irq.h>
+#include <linux/module.h>
+
+#include <asm/system.h>
+#include <asm/atomic.h>
+#include <asm/io.h>
+#include <asm/pci-bridge.h>
+#include <asm/prom.h>
+#include <sysdev/fsl_soc.h>
+
+#undef DEBUG
+
+#ifdef DEBUG
+#define DBG(x...) printk(x)
+#else
+#define DBG(x...)
+#endif
+
+int mpc83xx_pci2_busno;
+
+#ifdef CONFIG_PCI
+int __init add_bridge(struct device_node *dev)
+{
+        int len;
+        struct pci_controller *hose;
+        struct resource rsrc;
+        int *bus_range;
+        int primary = 1, has_address = 0;
+        phys_addr_t immr = get_immrbase();
+
+        DBG("Adding PCI host bridge %s\n", dev->full_name);
+
+        /* Fetch host bridge registers address */
+        has_address = (of_address_to_resource(dev, 0, &rsrc) == 0);
+
+        /* Get bus range if any */
+        bus_range = (int *) get_property(dev, "bus-range", &len);
+        if (bus_range == NULL || len < 2 * sizeof(int)) {
+                printk(KERN_WARNING "Can't get bus-range for %s, assume"
+                       " bus 0\n", dev->full_name);
+        }
+
+        hose = pcibios_alloc_controller();
+        if (!hose)
+                return -ENOMEM;
+        hose->arch_data = dev;
+        hose->set_cfg_type = 1;
+
+        hose->first_busno = bus_range ? bus_range[0] : 0;
+        hose->last_busno = bus_range ? bus_range[1] : 0xff;
+
+        /* MPC83xx supports up to two host controllers one at 0x8500 from immrbar
+         * the other at 0x8600, we consider the 0x8500 the primary controller
+         */
+        /* PCI 1 */
+        if ((rsrc.start & 0xfffff) == 0x8500) {
+                setup_indirect_pci(hose, immr + 0x8300, immr + 0x8304);
+        }
+        /* PCI 2*/
+        if ((rsrc.start & 0xfffff) == 0x8600) {
+                setup_indirect_pci(hose, immr + 0x8380, immr + 0x8384);
+                primary = 0;
+                hose->bus_offset = hose->first_busno;
+                mpc83xx_pci2_busno = hose->first_busno;
+        }
+
+        printk(KERN_INFO "Found MPC83xx PCI host bridge at 0x%08lx. "
+               "Firmware bus number: %d->%d\n",
+                rsrc.start, hose->first_busno, hose->last_busno);
+
+        DBG(" ->Hose at 0x%p, cfg_addr=0x%p,cfg_data=0x%p\n",
+                hose, hose->cfg_addr, hose->cfg_data);
+
+        /* Interpret the "ranges" property */
+        /* This also maps the I/O region and sets isa_io/mem_base */
+        pci_process_bridge_OF_ranges(hose, dev, primary);
+
+        return 0;
+}
+
+#endif
diff --git a/arch/powerpc/platforms/chrp/pci.c b/arch/powerpc/platforms/chrp/pci.c
index 82c429d487f3..00c52f27ef4f 100644
--- a/arch/powerpc/platforms/chrp/pci.c
+++ b/arch/powerpc/platforms/chrp/pci.c
@@ -135,12 +135,13 @@ int __init
 hydra_init(void)
 {
         struct device_node *np;
+        struct resource r;
 
         np = find_devices("mac-io");
-        if (np == NULL || np->n_addrs == 0)
+        if (np == NULL || of_address_to_resource(np, 0, &r))
                 return 0;
-        Hydra = ioremap(np->addrs[0].address, np->addrs[0].size);
-        printk("Hydra Mac I/O at %lx\n", np->addrs[0].address);
+        Hydra = ioremap(r.start, r.end-r.start);
+        printk("Hydra Mac I/O at %lx\n", r.start);
         printk("Hydra Feature_Control was %x",
                in_le32(&Hydra->Feature_Control));
         out_le32(&Hydra->Feature_Control, (HYDRA_FC_SCC_CELL_EN |
@@ -177,18 +178,24 @@ setup_python(struct pci_controller *hose, struct device_node *dev)
 {
         u32 __iomem *reg;
         u32 val;
-        unsigned long addr = dev->addrs[0].address;
+        struct resource r;
 
-        setup_indirect_pci(hose, addr + 0xf8000, addr + 0xf8010);
+        if (of_address_to_resource(dev, 0, &r)) {
+                printk(KERN_ERR "No address for Python PCI controller\n");
+                return;
+        }
 
         /* Clear the magic go-slow bit */
-        reg = ioremap(dev->addrs[0].address + 0xf6000, 0x40);
+        reg = ioremap(r.start + 0xf6000, 0x40);
+        BUG_ON(!reg); 
         val = in_be32(&reg[12]);
         if (val & PRG_CL_RESET_VALID) {
                 out_be32(&reg[12], val & ~PRG_CL_RESET_VALID);
                 in_be32(&reg[12]);
         }
         iounmap(reg);
+
+        setup_indirect_pci(hose, r.start + 0xf8000, r.start + 0xf8010);
 }
 
 /* Marvell Discovery II based Pegasos 2 */
@@ -218,7 +225,7 @@ chrp_find_bridges(void)
         char *model, *machine;
         int is_longtrail = 0, is_mot = 0, is_pegasos = 0;
         struct device_node *root = find_path_device("/");
-
+        struct resource r;
         /*
          * The PCI host bridge nodes on some machines don't have
          * properties to adequately identify them, so we have to
@@ -238,7 +245,7 @@ chrp_find_bridges(void)
                         continue;
                 ++index;
                 /* The GG2 bridge on the LongTrail doesn't have an address */
-                if (dev->n_addrs < 1 && !is_longtrail) {
+                if (of_address_to_resource(dev, 0, &r) && !is_longtrail) {
                         printk(KERN_WARNING "Can't use %s: no address\n",
                                dev->full_name);
                         continue;
@@ -255,8 +262,8 @@ chrp_find_bridges(void)
                         printk(KERN_INFO "PCI buses %d..%d",
                                bus_range[0], bus_range[1]);
                 printk(" controlled by %s", dev->type);
-                if (dev->n_addrs > 0)
-                        printk(" at %lx", dev->addrs[0].address);
+                if (!is_longtrail)
+                        printk(" at %lx", r.start);
                 printk("\n");
 
                 hose = pcibios_alloc_controller();
diff --git a/arch/powerpc/platforms/chrp/setup.c b/arch/powerpc/platforms/chrp/setup.c
index 4ec8ba737e7d..2dc87aa5962f 100644
--- a/arch/powerpc/platforms/chrp/setup.c
+++ b/arch/powerpc/platforms/chrp/setup.c
@@ -352,9 +352,10 @@ static void __init chrp_find_openpic(void)
                 opaddr = opprop[na-1];  /* assume 32-bit */
                 oplen /= na * sizeof(unsigned int);
         } else {
-                if (np->n_addrs == 0)
+                struct resource r;
+                if (of_address_to_resource(np, 0, &r))
                         return;
-                opaddr = np->addrs[0].address;
+                opaddr = r.start;
                 oplen = 0;
         }
 
@@ -377,7 +378,7 @@ static void __init chrp_find_openpic(void)
          */
         if (oplen < len) {
                 printk(KERN_ERR "Insufficient addresses for distributed"
-                       " OpenPIC (%d < %d)\n", np->n_addrs, len);
+                       " OpenPIC (%d < %d)\n", oplen, len);
                 len = oplen;
         }
 
diff --git a/arch/powerpc/platforms/chrp/time.c b/arch/powerpc/platforms/chrp/time.c
index 737ee5d9f0aa..36a0f97bb7b1 100644
--- a/arch/powerpc/platforms/chrp/time.c
+++ b/arch/powerpc/platforms/chrp/time.c
@@ -21,6 +21,7 @@
 #include <linux/mc146818rtc.h>
 #include <linux/init.h>
 #include <linux/bcd.h>
+#include <linux/ioport.h>
 
 #include <asm/io.h>
 #include <asm/nvram.h>
@@ -37,14 +38,16 @@ static int nvram_data = NVRAM_DATA;
 long __init chrp_time_init(void)
 {
         struct device_node *rtcs;
+        struct resource r;
         int base;
 
         rtcs = find_compatible_devices("rtc", "pnpPNP,b00");
         if (rtcs == NULL)
                 rtcs = find_compatible_devices("rtc", "ds1385-rtc");
-        if (rtcs == NULL || rtcs->addrs == NULL)
+        if (rtcs == NULL || of_address_to_resource(rtcs, 0, &r))
                 return 0;
-        base = rtcs->addrs[0].address;
+        
+        base = r.start;
         nvram_as1 = 0;
         nvram_as0 = base;
         nvram_data = base + 1;
diff --git a/arch/powerpc/platforms/iseries/irq.c b/arch/powerpc/platforms/iseries/irq.c
index 83442ea77476..be3fbfc24e6c 100644
--- a/arch/powerpc/platforms/iseries/irq.c
+++ b/arch/powerpc/platforms/iseries/irq.c
@@ -334,14 +334,12 @@ int __init iSeries_allocate_IRQ(HvBusNumber bus,
  */
 int iSeries_get_irq(struct pt_regs *regs)
 {
-        struct paca_struct *lpaca;
         /* -2 means ignore this interrupt */
         int irq = -2;
 
-        lpaca = get_paca();
 #ifdef CONFIG_SMP
-        if (lpaca->lppaca.int_dword.fields.ipi_cnt) {
-                lpaca->lppaca.int_dword.fields.ipi_cnt = 0;
+        if (get_lppaca()->int_dword.fields.ipi_cnt) {
+                get_lppaca()->int_dword.fields.ipi_cnt = 0;
                 iSeries_smp_message_recv(regs);
         }
 #endif /* CONFIG_SMP */
diff --git a/arch/powerpc/platforms/iseries/misc.S b/arch/powerpc/platforms/iseries/misc.S
index dfe7aa1ba098..7641fc7e550a 100644
--- a/arch/powerpc/platforms/iseries/misc.S
+++ b/arch/powerpc/platforms/iseries/misc.S
@@ -44,7 +44,8 @@ _GLOBAL(local_irq_restore)
         /* Check pending interrupts */
         /*   A decrementer, IPI or PMC interrupt may have occurred
          *   while we were in the hypervisor (which enables) */
-        ld      r4,PACALPPACA+LPPACAANYINT(r13)
+        ld      r4,PACALPPACAPTR(r13)
+        ld      r4,LPPACAANYINT(r4)
         cmpdi   r4,0
         beqlr
 
diff --git a/arch/powerpc/platforms/iseries/setup.c b/arch/powerpc/platforms/iseries/setup.c
index c6bbe5c25107..3f8790146b00 100644
--- a/arch/powerpc/platforms/iseries/setup.c
+++ b/arch/powerpc/platforms/iseries/setup.c
@@ -538,7 +538,7 @@ static unsigned long __init build_iSeries_Memory_Map(void)
  */
 static void __init iSeries_setup_arch(void)
 {
-        if (get_paca()->lppaca.shared_proc) {
+        if (get_lppaca()->shared_proc) {
                 ppc_md.idle_loop = iseries_shared_idle;
                 printk(KERN_INFO "Using shared processor idle loop\n");
         } else {
@@ -647,7 +647,7 @@ static void yield_shared_processor(void)
          * The decrementer stops during the yield.  Force a fake decrementer
          * here and let the timer_interrupt code sort out the actual time.
          */
-        get_paca()->lppaca.int_dword.fields.decr_int = 1;
+        get_lppaca()->int_dword.fields.decr_int = 1;
         process_iSeries_events();
 }
 
@@ -883,7 +883,7 @@ void dt_cpus(struct iseries_flat_dt *dt)
         pft_size[1] = __ilog2(HvCallHpt_getHptPages() * HW_PAGE_SIZE);
 
         for (i = 0; i < NR_CPUS; i++) {
-                if (paca[i].lppaca.dyn_proc_status >= 2)
+                if (lppaca[i].dyn_proc_status >= 2)
                         continue;
 
                 snprintf(p, 32 - (p - buf), "@%d", i);
@@ -891,7 +891,7 @@ void dt_cpus(struct iseries_flat_dt *dt)
 
                 dt_prop_str(dt, "device_type", "cpu");
 
-                index = paca[i].lppaca.dyn_hv_phys_proc_index;
+                index = lppaca[i].dyn_hv_phys_proc_index;
                 d = &xIoHriProcessorVpd[index];
 
                 dt_prop_u32(dt, "i-cache-size", d->xInstCacheSize * 1024);
diff --git a/arch/powerpc/platforms/iseries/smp.c b/arch/powerpc/platforms/iseries/smp.c
index fcb094ec6aec..6f9d407a709f 100644
--- a/arch/powerpc/platforms/iseries/smp.c
+++ b/arch/powerpc/platforms/iseries/smp.c
@@ -91,7 +91,7 @@ static void smp_iSeries_kick_cpu(int nr)
         BUG_ON((nr < 0) || (nr >= NR_CPUS));
 
         /* Verify that our partition has a processor nr */
-        if (paca[nr].lppaca.dyn_proc_status >= 2)
+        if (lppaca[nr].dyn_proc_status >= 2)
                 return;
 
         /* The processor is currently spinning, waiting
diff --git a/arch/powerpc/platforms/maple/pci.c b/arch/powerpc/platforms/maple/pci.c
index f40451da037c..7d4099a34f92 100644
--- a/arch/powerpc/platforms/maple/pci.c
+++ b/arch/powerpc/platforms/maple/pci.c
@@ -316,7 +316,6 @@ static int __init add_bridge(struct device_node *dev)
         char* disp_name;
         int *bus_range;
         int primary = 1;
-        struct property *of_prop;
 
         DBG("Adding PCI host bridge %s\n", dev->full_name);
 
diff --git a/arch/powerpc/platforms/maple/setup.c b/arch/powerpc/platforms/maple/setup.c
index a1cb4d236720..ec5c1e10c407 100644
--- a/arch/powerpc/platforms/maple/setup.c
+++ b/arch/powerpc/platforms/maple/setup.c
@@ -71,38 +71,60 @@
 #define DBG(fmt...)
 #endif
 
+static unsigned long maple_find_nvram_base(void)
+{
+        struct device_node *rtcs;
+        unsigned long result = 0;
+
+        /* find NVRAM device */
+        rtcs = of_find_compatible_node(NULL, "nvram", "AMD8111");
+        if (rtcs) {
+                struct resource r;
+                if (of_address_to_resource(rtcs, 0, &r)) {
+                        printk(KERN_EMERG "Maple: Unable to translate NVRAM"
+                               " address\n");
+                        goto bail;
+                }
+                if (!(r.flags & IORESOURCE_IO)) {
+                        printk(KERN_EMERG "Maple: NVRAM address isn't PIO!\n");
+                        goto bail;
+                }
+                result = r.start;
+        } else
+                printk(KERN_EMERG "Maple: Unable to find NVRAM\n");
+ bail:
+        of_node_put(rtcs);
+        return result;
+}
+
 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;
+        struct device_node *sp;
 
-        /* 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;
-        }
+        maple_nvram_base = maple_find_nvram_base();
+        if (maple_nvram_base == 0)
+                goto fail;
 
         /* find service processor device */
-        rtcs = find_devices("service-processor");
-        if (!rtcs) {
+        sp = of_find_node_by_name(NULL, "service-processor");
+        if (!sp) {
                 printk(KERN_EMERG "Maple: Unable to find Service Processor\n");
-                printk(KERN_EMERG "Maple: Manual Restart Required\n");
-                return;
+                goto fail;
         }
-        maple_nvram_offset = *(unsigned int*) get_property(rtcs,
+        maple_nvram_offset = *(unsigned int*) get_property(sp,
                         "restart-addr", NULL);
-        maple_nvram_command = *(unsigned int*) get_property(rtcs,
+        maple_nvram_command = *(unsigned int*) get_property(sp,
                         "restart-value", NULL);
+        of_node_put(sp);
 
         /* send command */
         outb_p(maple_nvram_command, maple_nvram_base + maple_nvram_offset);
         for (;;) ;
+ fail:
+        printk(KERN_EMERG "Maple: Manual Restart Required\n");
 }
 
 static void maple_power_off(void)
@@ -110,33 +132,29 @@ 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;
+        struct device_node *sp;
 
-        /* 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;
-        }
+        maple_nvram_base = maple_find_nvram_base();
+        if (maple_nvram_base == 0)
+                goto fail;
 
         /* find service processor device */
-        rtcs = find_devices("service-processor");
-        if (!rtcs) {
+        sp = of_find_node_by_name(NULL, "service-processor");
+        if (!sp) {
                 printk(KERN_EMERG "Maple: Unable to find Service Processor\n");
-                printk(KERN_EMERG "Maple: Manual Power-Down Required\n");
-                return;
+                goto fail;
         }
-        maple_nvram_offset = *(unsigned int*) get_property(rtcs,
+        maple_nvram_offset = *(unsigned int*) get_property(sp,
                         "power-off-addr", NULL);
-        maple_nvram_command = *(unsigned int*) get_property(rtcs,
+        maple_nvram_command = *(unsigned int*) get_property(sp,
                         "power-off-value", NULL);
+        of_node_put(sp);
 
         /* send command */
         outb_p(maple_nvram_command, maple_nvram_base + maple_nvram_offset);
         for (;;) ;
+ fail:
+        printk(KERN_EMERG "Maple: Manual Power-Down Required\n");
 }
 
 static void maple_halt(void)
@@ -179,9 +197,6 @@ void __init maple_setup_arch(void)
  */
 static void __init maple_init_early(void)
 {
-        unsigned int default_speed;
-        u64 physport;
-
         DBG(" -> maple_init_early\n");
 
         /* Initialize hash table, from now on, we can take hash faults
diff --git a/arch/powerpc/platforms/maple/time.c b/arch/powerpc/platforms/maple/time.c
index 15846cc938ac..50bc4eb85353 100644
--- a/arch/powerpc/platforms/maple/time.c
+++ b/arch/powerpc/platforms/maple/time.c
@@ -168,11 +168,24 @@ unsigned long __init maple_get_boot_time(void)
         struct rtc_time tm;
         struct device_node *rtcs;
 
-        rtcs = find_compatible_devices("rtc", "pnpPNP,b00");
-        if (rtcs && rtcs->addrs) {
-                maple_rtc_addr = rtcs->addrs[0].address;
-                printk(KERN_INFO "Maple: Found RTC at 0x%x\n", maple_rtc_addr);
-        } else {
+        rtcs = of_find_compatible_node(NULL, "rtc", "pnpPNP,b00");
+        if (rtcs) {
+                struct resource r;
+                if (of_address_to_resource(rtcs, 0, &r)) {
+                        printk(KERN_EMERG "Maple: Unable to translate RTC"
+                               " address\n");
+                        goto bail;
+                }
+                if (!(r.flags & IORESOURCE_IO)) {
+                        printk(KERN_EMERG "Maple: RTC address isn't PIO!\n");
+                        goto bail;
+                }
+                maple_rtc_addr = r.start;
+                printk(KERN_INFO "Maple: Found RTC at IO 0x%x\n",
+                       maple_rtc_addr);
+        }
+ bail:
+        if (maple_rtc_addr == 0) {
                 maple_rtc_addr = RTC_PORT(0); /* legacy address */
                 printk(KERN_INFO "Maple: No device node for RTC, assuming "
                        "legacy address (0x%x)\n", maple_rtc_addr);
diff --git a/arch/powerpc/platforms/pseries/lpar.c b/arch/powerpc/platforms/pseries/lpar.c
index 1fe445ab78a6..8952528d31ac 100644
--- a/arch/powerpc/platforms/pseries/lpar.c
+++ b/arch/powerpc/platforms/pseries/lpar.c
@@ -254,11 +254,11 @@ out:
 void vpa_init(int cpu)
 {
         int hwcpu = get_hard_smp_processor_id(cpu);
-        unsigned long vpa = __pa(&paca[cpu].lppaca);
+        unsigned long vpa = __pa(&lppaca[cpu]);
         long ret;
 
         if (cpu_has_feature(CPU_FTR_ALTIVEC))
-                paca[cpu].lppaca.vmxregs_in_use = 1;
+                lppaca[cpu].vmxregs_in_use = 1;
 
         ret = register_vpa(hwcpu, vpa);
 
diff --git a/arch/powerpc/platforms/pseries/reconfig.c b/arch/powerpc/platforms/pseries/reconfig.c
index d8864164dbe8..86cfa6ecdcf3 100644
--- a/arch/powerpc/platforms/pseries/reconfig.c
+++ b/arch/powerpc/platforms/pseries/reconfig.c
@@ -350,6 +350,100 @@ static int do_remove_node(char *buf)
         return rv;
 }
 
+static char *parse_node(char *buf, size_t bufsize, struct device_node **npp)
+{
+        char *handle_str;
+        phandle handle;
+        *npp = NULL;
+
+        handle_str = buf;
+
+        buf = strchr(buf, ' ');
+        if (!buf)
+                return NULL;
+        *buf = '\0';
+        buf++;
+
+        handle = simple_strtoul(handle_str, NULL, 10);
+
+        *npp = of_find_node_by_phandle(handle);
+        return buf;
+}
+
+static int do_add_property(char *buf, size_t bufsize)
+{
+        struct property *prop = NULL;
+        struct device_node *np;
+        unsigned char *value;
+        char *name, *end;
+        int length;
+        end = buf + bufsize;
+        buf = parse_node(buf, bufsize, &np);
+
+        if (!np)
+                return -ENODEV;
+
+        if (parse_next_property(buf, end, &name, &length, &value) == NULL)
+                return -EINVAL;
+
+        prop = new_property(name, length, value, NULL);
+        if (!prop)
+                return -ENOMEM;
+
+        prom_add_property(np, prop);
+
+        return 0;
+}
+
+static int do_remove_property(char *buf, size_t bufsize)
+{
+        struct device_node *np;
+        char *tmp;
+        struct property *prop;
+        buf = parse_node(buf, bufsize, &np);
+
+        if (!np)
+                return -ENODEV;
+
+        tmp = strchr(buf,' ');
+        if (tmp)
+                *tmp = '\0';
+
+        if (strlen(buf) == 0)
+                return -EINVAL;
+
+        prop = of_find_property(np, buf, NULL);
+
+        return prom_remove_property(np, prop);
+}
+
+static int do_update_property(char *buf, size_t bufsize)
+{
+        struct device_node *np;
+        unsigned char *value;
+        char *name, *end;
+        int length;
+        struct property *newprop, *oldprop;
+        buf = parse_node(buf, bufsize, &np);
+        end = buf + bufsize;
+
+        if (!np)
+                return -ENODEV;
+
+        if (parse_next_property(buf, end, &name, &length, &value) == NULL)
+                return -EINVAL;
+
+        newprop = new_property(name, length, value, NULL);
+        if (!newprop)
+                return -ENOMEM;
+
+        oldprop = of_find_property(np, name,NULL);
+        if (!oldprop)
+                return -ENODEV;
+
+        return prom_update_property(np, newprop, oldprop);
+}
+
 /**
  * ofdt_write - perform operations on the Open Firmware device tree
  *
@@ -392,6 +486,12 @@ static ssize_t ofdt_write(struct file *file, const char __user *buf, size_t coun
                 rv = do_add_node(tmp, count - (tmp - kbuf));
         else if (!strcmp(kbuf, "remove_node"))
                 rv = do_remove_node(tmp);
+        else if (!strcmp(kbuf, "add_property"))
+                rv = do_add_property(tmp, count - (tmp - kbuf));
+        else if (!strcmp(kbuf, "remove_property"))
+                rv = do_remove_property(tmp, count - (tmp - kbuf));
+        else if (!strcmp(kbuf, "update_property"))
+                rv = do_update_property(tmp, count - (tmp - kbuf));
         else
                 rv = -EINVAL;
 out:
diff --git a/arch/powerpc/platforms/pseries/setup.c b/arch/powerpc/platforms/pseries/setup.c
index 68b7f086d63d..da6cebaf72cd 100644
--- a/arch/powerpc/platforms/pseries/setup.c
+++ b/arch/powerpc/platforms/pseries/setup.c
@@ -190,7 +190,7 @@ static void pseries_lpar_enable_pmcs(void)
 
         /* instruct hypervisor to maintain PMCs */
         if (firmware_has_feature(FW_FEATURE_SPLPAR))
-                get_paca()->lppaca.pmcregs_in_use = 1;
+                get_lppaca()->pmcregs_in_use = 1;
 }
 
 static void __init pSeries_setup_arch(void)
@@ -234,7 +234,7 @@ static void __init pSeries_setup_arch(void)
         /* Choose an idle loop */
         if (firmware_has_feature(FW_FEATURE_SPLPAR)) {
                 vpa_init(boot_cpuid);
-                if (get_paca()->lppaca.shared_proc) {
+                if (get_lppaca()->shared_proc) {
                         printk(KERN_INFO "Using shared processor idle loop\n");
                         ppc_md.idle_loop = pseries_shared_idle;
                 } else {
@@ -444,10 +444,10 @@ DECLARE_PER_CPU(unsigned long, smt_snooze_delay);
 
 static inline void dedicated_idle_sleep(unsigned int cpu)
 {
-        struct paca_struct *ppaca = &paca[cpu ^ 1];
+        struct lppaca *plppaca = &lppaca[cpu ^ 1];
 
         /* Only sleep if the other thread is not idle */
-        if (!(ppaca->lppaca.idle)) {
+        if (!(plppaca->idle)) {
                 local_irq_disable();
 
                 /*
@@ -480,7 +480,6 @@ static inline void dedicated_idle_sleep(unsigned int cpu)
 
 static void pseries_dedicated_idle(void)
 { 
-        struct paca_struct *lpaca = get_paca();
         unsigned int cpu = smp_processor_id();
         unsigned long start_snooze;
         unsigned long *smt_snooze_delay = &__get_cpu_var(smt_snooze_delay);
@@ -491,7 +490,7 @@ static void pseries_dedicated_idle(void)
                  * Indicate to the HV that we are idle. Now would be
                  * a good time to find other work to dispatch.
                  */
-                lpaca->lppaca.idle = 1;
+                get_lppaca()->idle = 1;
 
                 if (!need_resched()) {
                         start_snooze = get_tb() +
@@ -518,7 +517,7 @@ static void pseries_dedicated_idle(void)
                         HMT_medium();
                 }
 
-                lpaca->lppaca.idle = 0;
+                get_lppaca()->idle = 0;
                 ppc64_runlatch_on();
 
                 preempt_enable_no_resched();
@@ -532,7 +531,6 @@ static void pseries_dedicated_idle(void)
 
 static void pseries_shared_idle(void)
 {
-        struct paca_struct *lpaca = get_paca();
         unsigned int cpu = smp_processor_id();
 
         while (1) {
@@ -540,7 +538,7 @@ static void pseries_shared_idle(void)
                  * Indicate to the HV that we are idle. Now would be
                  * a good time to find other work to dispatch.
                  */
-                lpaca->lppaca.idle = 1;
+                get_lppaca()->idle = 1;
 
                 while (!need_resched() && !cpu_is_offline(cpu)) {
                         local_irq_disable();
@@ -564,7 +562,7 @@ static void pseries_shared_idle(void)
                         HMT_medium();
                 }
 
-                lpaca->lppaca.idle = 0;
+                get_lppaca()->idle = 0;
                 ppc64_runlatch_on();
 
                 preempt_enable_no_resched();
@@ -588,7 +586,7 @@ static void pseries_kexec_cpu_down(int crash_shutdown, int secondary)
 {
         /* Don't risk a hypervisor call if we're crashing */
         if (!crash_shutdown) {
-                unsigned long vpa = __pa(&get_paca()->lppaca);
+                unsigned long vpa = __pa(get_lppaca());
 
                 if (unregister_vpa(hard_smp_processor_id(), vpa)) {
                         printk("VPA deregistration of cpu %u (hw_cpu_id %d) "
diff --git a/arch/powerpc/sysdev/Makefile b/arch/powerpc/sysdev/Makefile
index 0ae841347a09..4c2b356774ea 100644
--- a/arch/powerpc/sysdev/Makefile
+++ b/arch/powerpc/sysdev/Makefile
@@ -7,3 +7,4 @@ obj-$(CONFIG_40x)		+= dcr.o
 obj-$(CONFIG_U3_DART)           += dart_iommu.o
 obj-$(CONFIG_MMIO_NVRAM)        += mmio_nvram.o
 obj-$(CONFIG_PPC_83xx)          += ipic.o
+obj-$(CONFIG_FSL_SOC)           += fsl_soc.o
diff --git a/arch/powerpc/sysdev/fsl_soc.c b/arch/powerpc/sysdev/fsl_soc.c
new file mode 100644
index 000000000000..064c9de47732
--- /dev/null
+++ b/arch/powerpc/sysdev/fsl_soc.c
@@ -0,0 +1,317 @@
+/*
+ * FSL SoC setup code
+ *
+ * Maintained by Kumar Gala (see MAINTAINERS for contact information)
+ *
+ * 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 <linux/config.h>
+#include <linux/stddef.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/major.h>
+#include <linux/delay.h>
+#include <linux/irq.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/fsl_devices.h>
+
+#include <asm/system.h>
+#include <asm/atomic.h>
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/prom.h>
+#include <sysdev/fsl_soc.h>
+#include <mm/mmu_decl.h>
+
+static phys_addr_t immrbase = -1;
+
+phys_addr_t get_immrbase(void)
+{
+        struct device_node *soc;
+
+        if (immrbase != -1)
+                return immrbase;
+
+        soc = of_find_node_by_type(NULL, "soc");
+        if (soc != 0) {
+                unsigned int size;
+                void *prop = get_property(soc, "reg", &size);
+                immrbase = of_translate_address(soc, prop);
+                of_node_put(soc);
+        };
+
+        return immrbase;
+}
+EXPORT_SYMBOL(get_immrbase);
+
+static const char * gfar_tx_intr = "tx";
+static const char * gfar_rx_intr = "rx";
+static const char * gfar_err_intr = "error";
+
+static int __init gfar_of_init(void)
+{
+        struct device_node *np;
+        unsigned int i;
+        struct platform_device *mdio_dev, *gfar_dev;
+        struct resource res;
+        int ret;
+
+        for (np = NULL, i = 0; (np = of_find_compatible_node(np, "mdio", "gianfar")) != NULL; i++) {
+                int k;
+                struct device_node *child = NULL;
+                struct gianfar_mdio_data mdio_data;
+
+                memset(&res, 0, sizeof(res));
+                memset(&mdio_data, 0, sizeof(mdio_data));
+
+                ret = of_address_to_resource(np, 0, &res);
+                if (ret)
+                        goto mdio_err;
+
+                mdio_dev = platform_device_register_simple("fsl-gianfar_mdio", res.start, &res, 1);
+                if (IS_ERR(mdio_dev)) {
+                        ret = PTR_ERR(mdio_dev);
+                        goto mdio_err;
+                }
+
+                for (k = 0; k < 32; k++)
+                        mdio_data.irq[k] = -1;
+
+                while ((child = of_get_next_child(np, child)) != NULL) {
+                        if (child->n_intrs) {
+                                u32 *id = (u32 *) get_property(child, "reg", NULL);
+                                mdio_data.irq[*id] = child->intrs[0].line;
+                        }
+                }
+
+                ret = platform_device_add_data(mdio_dev, &mdio_data, sizeof(struct gianfar_mdio_data));
+                if (ret)
+                        goto mdio_unreg;
+        }
+
+        for (np = NULL, i = 0; (np = of_find_compatible_node(np, "network", "gianfar")) != NULL; i++) {
+                struct resource r[4];
+                struct device_node *phy, *mdio;
+                struct gianfar_platform_data gfar_data;
+                unsigned int *id;
+                char *model;
+                void *mac_addr;
+                phandle *ph;
+
+                memset(r, 0, sizeof(r));
+                memset(&gfar_data, 0, sizeof(gfar_data));
+
+                ret = of_address_to_resource(np, 0, &r[0]);
+                if (ret)
+                        goto gfar_err;
+
+                r[1].start = np->intrs[0].line;
+                r[1].end = np->intrs[0].line;
+                r[1].flags = IORESOURCE_IRQ;
+
+                model = get_property(np, "model", NULL);
+
+                /* If we aren't the FEC we have multiple interrupts */
+                if (model && strcasecmp(model, "FEC")) {
+                        r[1].name = gfar_tx_intr;
+
+                        r[2].name = gfar_rx_intr;
+                        r[2].start = np->intrs[1].line;
+                        r[2].end = np->intrs[1].line;
+                        r[2].flags = IORESOURCE_IRQ;
+
+                        r[3].name = gfar_err_intr;
+                        r[3].start = np->intrs[2].line;
+                        r[3].end = np->intrs[2].line;
+                        r[3].flags = IORESOURCE_IRQ;
+                }
+
+                gfar_dev = platform_device_register_simple("fsl-gianfar", i, &r[0], np->n_intrs + 1);
+
+                if (IS_ERR(gfar_dev)) {
+                        ret = PTR_ERR(gfar_dev);
+                        goto gfar_err;
+                }
+
+                mac_addr = get_property(np, "address", NULL);
+                memcpy(gfar_data.mac_addr, mac_addr, 6);
+
+                if (model && !strcasecmp(model, "TSEC"))
+                        gfar_data.device_flags =
+                                FSL_GIANFAR_DEV_HAS_GIGABIT |
+                                FSL_GIANFAR_DEV_HAS_COALESCE |
+                                FSL_GIANFAR_DEV_HAS_RMON |
+                                FSL_GIANFAR_DEV_HAS_MULTI_INTR;
+                if (model && !strcasecmp(model, "eTSEC"))
+                        gfar_data.device_flags =
+                                FSL_GIANFAR_DEV_HAS_GIGABIT |
+                                FSL_GIANFAR_DEV_HAS_COALESCE |
+                                FSL_GIANFAR_DEV_HAS_RMON |
+                                FSL_GIANFAR_DEV_HAS_MULTI_INTR |
+                                FSL_GIANFAR_DEV_HAS_CSUM |
+                                FSL_GIANFAR_DEV_HAS_VLAN |
+                                FSL_GIANFAR_DEV_HAS_EXTENDED_HASH;
+
+                ph = (phandle *) get_property(np, "phy-handle", NULL);
+                phy = of_find_node_by_phandle(*ph);
+
+                if (phy == NULL) {
+                        ret = -ENODEV;
+                        goto gfar_unreg;
+                }
+
+                mdio = of_get_parent(phy);
+
+                id = (u32 *) get_property(phy, "reg", NULL);
+                ret = of_address_to_resource(mdio, 0, &res);
+                if (ret) {
+                        of_node_put(phy);
+                        of_node_put(mdio);
+                        goto gfar_unreg;
+                }
+
+                gfar_data.phy_id = *id;
+                gfar_data.bus_id = res.start;
+
+                of_node_put(phy);
+                of_node_put(mdio);
+
+                ret = platform_device_add_data(gfar_dev, &gfar_data, sizeof(struct gianfar_platform_data));
+                if (ret)
+                        goto gfar_unreg;
+        }
+
+        return 0;
+
+mdio_unreg:
+        platform_device_unregister(mdio_dev);
+mdio_err:
+        return ret;
+
+gfar_unreg:
+        platform_device_unregister(gfar_dev);
+gfar_err:
+        return ret;
+}
+arch_initcall(gfar_of_init);
+
+static int __init fsl_i2c_of_init(void)
+{
+        struct device_node *np;
+        unsigned int i;
+        struct platform_device *i2c_dev;
+        int ret;
+
+        for (np = NULL, i = 0; (np = of_find_compatible_node(np, "i2c", "fsl-i2c")) != NULL; i++) {
+                struct resource r[2];
+                struct fsl_i2c_platform_data i2c_data;
+                unsigned char * flags = NULL;
+
+                memset(&r, 0, sizeof(r));
+                memset(&i2c_data, 0, sizeof(i2c_data));
+
+                ret = of_address_to_resource(np, 0, &r[0]);
+                if (ret)
+                        goto i2c_err;
+
+                r[1].start = np->intrs[0].line;
+                r[1].end = np->intrs[0].line;
+                r[1].flags = IORESOURCE_IRQ;
+
+                i2c_dev = platform_device_register_simple("fsl-i2c", i, r, 2);
+                if (IS_ERR(i2c_dev)) {
+                        ret = PTR_ERR(i2c_dev);
+                        goto i2c_err;
+                }
+
+                i2c_data.device_flags = 0;
+                flags = get_property(np, "dfsrr", NULL);
+                if (flags)
+                        i2c_data.device_flags |= FSL_I2C_DEV_SEPARATE_DFSRR;
+
+                flags = get_property(np, "fsl5200-clocking", NULL);
+                if (flags)
+                        i2c_data.device_flags |= FSL_I2C_DEV_CLOCK_5200;
+
+                ret = platform_device_add_data(i2c_dev, &i2c_data, sizeof(struct fsl_i2c_platform_data));
+                if (ret)
+                        goto i2c_unreg;
+        }
+
+        return 0;
+
+i2c_unreg:
+        platform_device_unregister(i2c_dev);
+i2c_err:
+        return ret;
+}
+arch_initcall(fsl_i2c_of_init);
+
+#ifdef CONFIG_PPC_83xx
+static int __init mpc83xx_wdt_init(void)
+{
+        struct resource r;
+        struct device_node *soc, *np;
+        struct platform_device *dev;
+        unsigned int *freq;
+        int ret;
+
+        np = of_find_compatible_node(NULL, "watchdog", "mpc83xx_wdt");
+
+        if (!np) {
+                ret = -ENODEV;
+                goto mpc83xx_wdt_nodev;
+        }
+
+        soc = of_find_node_by_type(NULL, "soc");
+
+        if (!soc) {
+                ret = -ENODEV;
+                goto mpc83xx_wdt_nosoc;
+        }
+
+        freq = (unsigned int *)get_property(soc, "bus-frequency", NULL);
+        if (!freq) {
+                ret = -ENODEV;
+                goto mpc83xx_wdt_err;
+        }
+
+        memset(&r, 0, sizeof(r));
+
+        ret = of_address_to_resource(np, 0, &r);
+        if (ret)
+                goto mpc83xx_wdt_err;
+
+        dev = platform_device_register_simple("mpc83xx_wdt", 0, &r, 1);
+        if (IS_ERR(dev)) {
+                ret = PTR_ERR(dev);
+                goto mpc83xx_wdt_err;
+        }
+
+        ret = platform_device_add_data(dev, freq, sizeof(int));
+        if (ret)
+                goto mpc83xx_wdt_unreg;
+
+        of_node_put(soc);
+        of_node_put(np);
+
+        return 0;
+
+mpc83xx_wdt_unreg:
+        platform_device_unregister(dev);
+mpc83xx_wdt_err:
+        of_node_put(soc);
+mpc83xx_wdt_nosoc:
+        of_node_put(np);
+mpc83xx_wdt_nodev:
+        return ret;
+}
+arch_initcall(mpc83xx_wdt_init);
+#endif
diff --git a/arch/powerpc/sysdev/fsl_soc.h b/arch/powerpc/sysdev/fsl_soc.h
new file mode 100644
index 000000000000..c433d3f39edd
--- /dev/null
+++ b/arch/powerpc/sysdev/fsl_soc.h
@@ -0,0 +1,8 @@
+#ifndef __PPC_FSL_SOC_H
+#define __PPC_FSL_SOC_H
+#ifdef __KERNEL__
+
+extern phys_addr_t get_immrbase(void);
+
+#endif
+#endif
diff --git a/arch/ppc/4xx_io/serial_sicc.c b/arch/ppc/4xx_io/serial_sicc.c
index ebc4db8fcc63..8ace2a1f3b48 100644
--- a/arch/ppc/4xx_io/serial_sicc.c
+++ b/arch/ppc/4xx_io/serial_sicc.c
@@ -215,7 +215,6 @@ static struct tty_driver *siccnormal_driver;
  * memory if large numbers of serial ports are open.
  */
 static u_char *tmp_buf;
-static DECLARE_MUTEX(tmp_buf_sem);
 
 #define HIGH_BITS_OFFSET    ((sizeof(long)-sizeof(int))*8)
 
diff --git a/arch/ppc/Kconfig b/arch/ppc/Kconfig
index d65810108bc3..11899f06bf06 100644
--- a/arch/ppc/Kconfig
+++ b/arch/ppc/Kconfig
@@ -58,11 +58,11 @@ config 6xx
         help
           There are four types of PowerPC chips supported.  The more common
           types (601, 603, 604, 740, 750, 7400), the Motorola embedded
-          versions (821, 823, 850, 855, 860, 52xx, 82xx, 83xx), the IBM embedded
-          versions (403 and 405) and the high end 64 bit Power processors
-          (POWER 3, POWER4, and IBM 970 also known as G5)
+          versions (821, 823, 850, 855, 860, 52xx, 82xx, 83xx), the IBM
+          embedded versions (403 and 405) and the POWER3 processor.
+          (For support for more recent 64-bit processors, set ARCH=powerpc.)
           Unless you are building a kernel for one of the embedded processor
-          systems, 64 bit IBM RS/6000 or an Apple G5, choose 6xx.
+          systems or a POWER3-based IBM RS/6000, choose 6xx.
           Note that the kernel runs in 32-bit mode even on 64-bit chips.
           Also note that because the 52xx, 82xx, & 83xx family has a 603e core,
           specific support for that chipset is asked later on.
@@ -77,10 +77,6 @@ config POWER3
         select PPC_FPU
         bool "POWER3"
 
-config POWER4
-        select PPC_FPU
-        bool "POWER4 and 970 (G5)"
-
 config 8xx
         bool "8xx"
 
@@ -123,7 +119,7 @@ config PHYS_64BIT
 
 config ALTIVEC
         bool "AltiVec Support"
-        depends on 6xx || POWER4
+        depends on 6xx
         depends on !8260 && !83xx
         ---help---
           This option enables kernel support for the Altivec extensions to the
@@ -235,18 +231,9 @@ config KEXEC
 
 source "drivers/cpufreq/Kconfig"
 
-config CPU_FREQ_PMAC
-        bool "Support for Apple PowerBooks"
-        depends on CPU_FREQ && ADB_PMU
-        select CPU_FREQ_TABLE
-        help
-          This adds support for frequency switching on Apple PowerBooks,
-          this currently includes some models of iBook & Titanium
-          PowerBook.
-
 config PPC601_SYNC_FIX
         bool "Workarounds for PPC601 bugs"
-        depends on 6xx && (PPC_PREP || PPC_PMAC)
+        depends on 6xx && PPC_PREP
         help
           Some versions of the PPC601 (the first PowerPC chip) have bugs which
           mean that extra synchronization instructions are required near
@@ -258,26 +245,17 @@ config PPC601_SYNC_FIX
 
           If in doubt, say Y here.
 
-config HOTPLUG_CPU
-        bool "Support for enabling/disabling CPUs"
-        depends on SMP && HOTPLUG && EXPERIMENTAL && PPC_PMAC
-        ---help---
-          Say Y here to be able to disable and re-enable individual
-          CPUs at runtime on SMP machines.
-
-          Say N if you are unsure.
-
 source arch/ppc/platforms/4xx/Kconfig
 source arch/ppc/platforms/85xx/Kconfig
 
 config PPC64BRIDGE
         bool
-        depends on POWER3 || POWER4
+        depends on POWER3
         default y
 
 config PPC_STD_MMU
         bool
-        depends on 6xx || POWER3 || POWER4
+        depends on 6xx || POWER3
         default y
 
 config NOT_COHERENT_CACHE
@@ -505,7 +483,7 @@ endchoice
 
 choice
         prompt "Machine Type"
-        depends on 6xx || POWER3 || POWER4
+        depends on 6xx || POWER3
         default PPC_MULTIPLATFORM
         ---help---
           Linux currently supports several different kinds of PowerPC-based
@@ -516,11 +494,15 @@ choice
           Platform) machines (including all of the recent IBM RS/6000 and
           pSeries machines), and several embedded PowerPC systems containing
           4xx, 6xx, 7xx, 8xx, 74xx, and 82xx processors.  Currently, the
-          default option is to build a kernel which works on the first three.
+          default option is to build a kernel which works on PReP and CHRP.
 
-          Select CHRP/PowerMac/PReP if configuring for an IBM RS/6000 or
-          pSeries machine, a Power Macintosh (including iMacs, iBooks and
-          Powerbooks), or a PReP machine.
+          Note that support for Apple machines is now only available with
+          ARCH=powerpc, and has been removed from this menu.  If you wish
+          to build a kernel for an Apple machine, exit this configuration
+          process and re-run it with ARCH=powerpc.
+
+          Select CHRP/PReP if configuring for an IBM RS/6000 or
+          pSeries machine, or a PReP machine.
 
           Select Gemini if configuring for a Synergy Microsystems' Gemini
           series Single Board Computer.  More information is available at:
@@ -530,7 +512,7 @@ choice
           available at: <http://linux-apus.sourceforge.net/>.
 
 config PPC_MULTIPLATFORM
-        bool "CHRP/PowerMac/PReP"
+        bool "CHRP/PReP"
 
 config APUS
         bool "Amiga-APUS"
@@ -768,25 +750,14 @@ config CPM2
           on it (826x, 827x, 8560).
 
 config PPC_CHRP
-        bool
+        bool "Support for CHRP (Common Hardware Reference Platform) machines"
         depends on PPC_MULTIPLATFORM
         select PPC_I8259
         select PPC_INDIRECT_PCI
         default y
 
-config PPC_PMAC
-        bool
-        depends on PPC_MULTIPLATFORM
-        select PPC_INDIRECT_PCI
-        default y
-
-config PPC_PMAC64
-        bool
-        depends on PPC_PMAC && POWER4
-        default y
-
 config PPC_PREP
-        bool
+        bool "Support for PReP (PowerPC Reference Platform) machines"
         depends on PPC_MULTIPLATFORM
         select PPC_I8259
         select PPC_INDIRECT_PCI
@@ -794,7 +765,7 @@ config PPC_PREP
 
 config PPC_OF
         bool
-        depends on PPC_PMAC || PPC_CHRP
+        depends on PPC_CHRP
         default y
 
 config PPC_GEN550
@@ -1166,7 +1137,7 @@ config ISA
 
 config GENERIC_ISA_DMA
         bool
-        depends on POWER3 || POWER4 || 6xx && !CPM2
+        depends on POWER3 || 6xx && !CPM2
         default y
 
 config PPC_I8259
diff --git a/arch/ppc/boot/Makefile b/arch/ppc/boot/Makefile
index 995f89bb049c..efd8ce515d5f 100644
--- a/arch/ppc/boot/Makefile
+++ b/arch/ppc/boot/Makefile
@@ -18,7 +18,7 @@ BOOT_TARGETS	= zImage zImage.initrd znetboot znetboot.initrd
 bootdir-y                       := simple
 bootdir-$(CONFIG_PPC_OF)        += openfirmware
 subdir-y                        := lib common images
-subdir-$(CONFIG_PPC_OF)         += of1275
+subdir-$(CONFIG_PPC_MULTIPLATFORM)      += of1275
 
 # for cleaning
 subdir-                         += simple openfirmware
diff --git a/arch/ppc/boot/openfirmware/Makefile b/arch/ppc/boot/openfirmware/Makefile
index 83a6433459ce..2a411ec2e650 100644
--- a/arch/ppc/boot/openfirmware/Makefile
+++ b/arch/ppc/boot/openfirmware/Makefile
@@ -21,26 +21,16 @@ bootlib	:= $(boot)/lib
 of1275  := $(boot)/of1275
 images  := $(boot)/images
 
-OBJCOPY_ARGS    := -O aixcoff-rs6000 -R .stab -R .stabstr -R .comment
-COFF_LD_ARGS    := -T $(srctree)/$(boot)/ld.script -e _start -Ttext 0x00500000 \
-                        -Bstatic
 CHRP_LD_ARGS    := -T $(srctree)/$(boot)/ld.script -e _start -Ttext 0x00800000
-NEWWORLD_LD_ARGS:= -T $(srctree)/$(boot)/ld.script -e _start -Ttext 0x01000000
 
 COMMONOBJS      := start.o misc.o common.o
-COFFOBJS        := coffcrt0.o $(COMMONOBJS) coffmain.o
 CHRPOBJS        := crt0.o     $(COMMONOBJS) chrpmain.o
-NEWWORLDOBJS    := crt0.o     $(COMMONOBJS) newworldmain.o
 
-targets         := $(COFFOBJS) $(CHRPOBJS) $(NEWWORLDOBJS) dummy.o
-COFFOBJS        := $(addprefix $(obj)/, $(COFFOBJS))
+targets         := $(CHRPOBJS) dummy.o
 CHRPOBJS        := $(addprefix $(obj)/, $(CHRPOBJS))
-NEWWORLDOBJS    := $(addprefix $(obj)/, $(NEWWORLDOBJS))
 
 LIBS            := lib/lib.a $(bootlib)/lib.a $(of1275)/lib.a $(common)/lib.a
 
-HACKCOFF := $(utils)/hack-coff
-
 ifdef CONFIG_SMP
 END := .smp
 endif
@@ -72,56 +62,11 @@ targets += image.initrd.o
 $(obj)/image.initrd.o: $(obj)/image.o $(images)/ramdisk.image.gz FORCE
         $(call if_changed,genimage-initrd)
 
-# Create the note section for New-World PowerMacs.
-quiet_cmd_mknote = MKNOTE  $@
-     cmd_mknote  = $(utils)/mknote > $@
-targets         += note
-$(obj)/note: $(utils)/mknote FORCE
-        $(call if_changed,mknote)
-
 
-$(obj)/coffcrt0.o: EXTRA_AFLAGS := -DXCOFF
-targets += coffcrt0.o crt0.o
-$(obj)/coffcrt0.o $(obj)/crt0.o: $(common)/crt0.S FORCE
+targets += crt0.o
+$(obj)/crt0.o: $(common)/crt0.S FORCE
         $(call if_changed_dep,as_o_S)
 
-quiet_cmd_gencoffb = COFF    $@
-      cmd_gencoffb = $(LD) -o $@ $(COFF_LD_ARGS) $(COFFOBJS) $< $(LIBS) && \
-                     $(OBJCOPY) $@ $@ -R .comment $(del-ramdisk-sec)
-targets += coffboot
-$(obj)/coffboot: $(obj)/image.o $(COFFOBJS) $(LIBS) $(srctree)/$(boot)/ld.script FORCE
-        $(call if_changed,gencoffb)
-targets += coffboot.initrd
-$(obj)/coffboot.initrd: $(obj)/image.initrd.o $(COFFOBJS) $(LIBS) \
-                        $(srctree)/$(boot)/ld.script FORCE
-        $(call if_changed,gencoffb)
-
-
-quiet_cmd_gen-coff = COFF    $@
-      cmd_gen-coff = $(OBJCOPY) $(OBJCOPY_ARGS) $< $@ && \
-                        $(HACKCOFF) $@ && \
-                        ln -sf $(notdir $@) $(images)/zImage$(initrd).pmac
-
-$(images)/vmlinux.coff: $(obj)/coffboot
-        $(call cmd,gen-coff)
-
-$(images)/vmlinux.initrd.coff: $(obj)/coffboot.initrd
-        $(call cmd,gen-coff)
-
-quiet_cmd_gen-elf-pmac = ELF     $@
-      cmd_gen-elf-pmac = $(LD) $(NEWWORLD_LD_ARGS) -o $@ \
-                                $(NEWWORLDOBJS) $(LIBS) $< && \
-                        $(OBJCOPY) $@ $@ --add-section=.note=$(obj)/note \
-                                         -R .comment $(del-ramdisk-sec)
-
-$(images)/vmlinux.elf-pmac: $(obj)/image.o $(NEWWORLDOBJS) $(LIBS) \
-                        $(obj)/note $(srctree)/$(boot)/ld.script
-        $(call cmd,gen-elf-pmac)
-$(images)/vmlinux.initrd.elf-pmac: $(obj)/image.initrd.o $(NEWWORLDOBJS) \
-                                   $(LIBS) $(obj)/note \
-                                   $(srctree)/$(boot)/ld.script
-        $(call cmd,gen-elf-pmac)
-
 quiet_cmd_gen-chrp = CHRP    $@
       cmd_gen-chrp = $(LD) $(CHRP_LD_ARGS) -o $@ $(CHRPOBJS) $< $(LIBS) && \
                         $(OBJCOPY) $@ $@ -R .comment $(del-ramdisk-sec)
@@ -139,46 +84,23 @@ $(images)/zImage.chrp-rs6k $(images)/zImage.initrd.chrp-rs6k: \
         %-rs6k: %
         $(call cmd,addnote)
 
-quiet_cmd_gen-miboot = GEN     $@
-      cmd_gen-miboot = $(OBJCOPY) $(OBJCOPY_ARGS) \
-                       --add-section=$1=$(word 2, $^) $< $@
-$(images)/miboot.image: $(obj)/dummy.o $(images)/vmlinux.gz
-        $(call cmd,gen-miboot,image)
-
-$(images)/miboot.initrd.image: $(images)/miboot.image $(images)/ramdisk.image.gz
-        $(call cmd,gen-miboot,initrd)
-
 # The targets used on the make command-line
 
 .PHONY: zImage zImage.initrd
-zImage:          $(images)/vmlinux.coff         \
-                 $(images)/vmlinux.elf-pmac     \
-                 $(images)/zImage.chrp          \
-                 $(images)/zImage.chrp-rs6k     \
-                 $(images)/miboot.image
+zImage:          $(images)/zImage.chrp          \
+                 $(images)/zImage.chrp-rs6k
         @echo '  kernel: $@ is ready ($<)'
-zImage.initrd:   $(images)/vmlinux.initrd.coff          \
-                 $(images)/vmlinux.initrd.elf-pmac      \
-                 $(images)/zImage.initrd.chrp           \
-                 $(images)/zImage.initrd.chrp-rs6k      \
-                 $(images)/miboot.initrd.image
+zImage.initrd:   $(images)/zImage.initrd.chrp           \
+                 $(images)/zImage.initrd.chrp-rs6k
         @echo '  kernel: $@ is ready ($<)'
 
 TFTPIMAGE       := /tftpboot/zImage
 
 .PHONY: znetboot znetboot.initrd
-znetboot:       $(images)/vmlinux.coff          \
-                $(images)/vmlinux.elf-pmac      \
-                $(images)/zImage.chrp
-        cp $(images)/vmlinux.coff     $(TFTPIMAGE).pmac$(END)
-        cp $(images)/vmlinux.elf-pmac $(TFTPIMAGE).pmac$(END).elf
+znetboot:       $(images)/zImage.chrp
         cp $(images)/zImage.chrp      $(TFTPIMAGE).chrp$(END)
         @echo '  kernel: $@ is ready ($<)'
-znetboot.initrd:$(images)/vmlinux.initrd.coff           \
-                $(images)/vmlinux.initrd.elf-pmac       \
-                $(images)/zImage.initrd.chrp
-        cp $(images)/vmlinux.initrd.coff     $(TFTPIMAGE).pmac$(END)
-        cp $(images)/vmlinux.initrd.elf-pmac $(TFTPIMAGE).pmac$(END).elf
+znetboot.initrd:$(images)/zImage.initrd.chrp
         cp $(images)/zImage.initrd.chrp      $(TFTPIMAGE).chrp$(END)
         @echo '  kernel: $@ is ready ($<)'
 
diff --git a/arch/ppc/boot/openfirmware/coffmain.c b/arch/ppc/boot/openfirmware/coffmain.c
deleted file mode 100644
index 2da8855e2be0..000000000000
--- a/arch/ppc/boot/openfirmware/coffmain.c
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * Copyright (C) Paul Mackerras 1997.
- *
- * 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 <linux/string.h>
-#include <asm/processor.h>
-#include <asm/page.h>
-
-#include "nonstdio.h"
-#include "of1275.h"
-
-/* Passed from the linker */
-extern char __image_begin, __image_end;
-extern char __ramdisk_begin[], __ramdisk_end;
-extern char _start, _end;
-
-extern char image_data[], initrd_data[];
-extern int initrd_len, image_len;
-extern unsigned int heap_max;
-extern void flush_cache(void *start, unsigned int len);
-extern void gunzip(void *, int, unsigned char *, int *);
-extern void make_bi_recs(unsigned long addr, char *name, unsigned int mach,
-                unsigned int progend);
-extern void setup_bats(unsigned long start);
-
-char *avail_ram;
-char *begin_avail, *end_avail;
-char *avail_high;
-
-#define SCRATCH_SIZE    (128 << 10)
-
-static char heap[SCRATCH_SIZE];
-
-static unsigned long ram_start = 0;
-static unsigned long ram_end = 0x1000000;
-
-static unsigned long prog_start = 0x800000;
-static unsigned long prog_size = 0x700000;
-
-typedef void (*kernel_start_t)(int, int, void *);
-
-void boot(int a1, int a2, void *prom)
-{
-    unsigned sa, len;
-    void *dst;
-    unsigned char *im;
-    unsigned initrd_start, initrd_size;
-
-    printf("coffboot starting: loaded at 0x%p\n", &_start);
-    setup_bats(ram_start);
-
-    initrd_size = (char *)(&__ramdisk_end) - (char *)(&__ramdisk_begin);
-    if (initrd_size) {
-        initrd_start = (ram_end - initrd_size) & ~0xFFF;
-        a1 = initrd_start;
-        a2 = initrd_size;
-        claim(initrd_start, ram_end - initrd_start, 0);
-        printf("initial ramdisk moving 0x%x <- 0x%p (%x bytes)\n\r",
-               initrd_start, (char *)(&__ramdisk_begin), initrd_size);
-        memcpy((char *)initrd_start, (char *)(&__ramdisk_begin), initrd_size);
-        prog_size = initrd_start - prog_start;
-    } else
-        a2 = 0xdeadbeef;
-
-    im = (char *)(&__image_begin);
-    len = (char *)(&__image_end) - (char *)(&__image_begin);
-    /* claim 4MB starting at PROG_START */
-    claim(prog_start, prog_size, 0);
-    map(prog_start, prog_start, prog_size);
-    dst = (void *) prog_start;
-    if (im[0] == 0x1f && im[1] == 0x8b) {
-        /* set up scratch space */
-        begin_avail = avail_high = avail_ram = heap;
-        end_avail = heap + sizeof(heap);
-        printf("heap at 0x%p\n", avail_ram);
-        printf("gunzipping (0x%p <- 0x%p:0x%p)...", dst, im, im+len);
-        gunzip(dst, prog_size, im, &len);
-        printf("done %u bytes\n", len);
-        printf("%u bytes of heap consumed, max in use %u\n",
-               avail_high - begin_avail, heap_max);
-    } else {
-        memmove(dst, im, len);
-    }
-
-    flush_cache(dst, len);
-    make_bi_recs(((unsigned long) dst + len), "coffboot", _MACH_Pmac,
-                    (prog_start + prog_size));
-
-    sa = (unsigned long)prog_start;
-    printf("start address = 0x%x\n", sa);
-
-    (*(kernel_start_t)sa)(a1, a2, prom);
-
-    printf("returned?\n");
-
-    pause();
-}
diff --git a/arch/ppc/boot/openfirmware/newworldmain.c b/arch/ppc/boot/openfirmware/newworldmain.c
deleted file mode 100644
index fa8a8f9313f9..000000000000
--- a/arch/ppc/boot/openfirmware/newworldmain.c
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright (C) Paul Mackerras 1997.
- *
- * 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 <linux/string.h>
-#include "nonstdio.h"
-#include "of1275.h"
-#include <asm/processor.h>
-#include <asm/page.h>
-
-/* Passed from the linker */
-extern char __image_begin, __image_end;
-extern char __ramdisk_begin[], __ramdisk_end;
-extern char _start, _end;
-
-extern unsigned int heap_max;
-extern void flush_cache(void *start, unsigned int len);
-extern void gunzip(void *, int, unsigned char *, int *);
-extern void make_bi_recs(unsigned long addr, char *name, unsigned int mach,
-                unsigned int progend);
-
-char *avail_ram;
-char *begin_avail, *end_avail;
-char *avail_high;
-
-
-#define RAM_END         (16 << 20)
-
-#define PROG_START      0x00010000
-#define PROG_SIZE       0x007f0000
-
-#define SCRATCH_SIZE    (128 << 10)
-
-typedef void (*kernel_start_t)(int, int, void *);
-
-void boot(int a1, int a2, void *prom)
-{
-    unsigned sa, len;
-    void *dst;
-    unsigned char *im;
-    unsigned initrd_start, initrd_size;
-
-    printf("chrpboot starting: loaded at 0x%p\n", &_start);
-
-    initrd_size = (char *)(&__ramdisk_end) - (char *)(&__ramdisk_begin);
-    if (initrd_size) {
-        initrd_start = (RAM_END - initrd_size) & ~0xFFF;
-        a1 = initrd_start;
-        a2 = initrd_size;
-        claim(initrd_start, RAM_END - initrd_start, 0);
-        printf("initial ramdisk moving 0x%x <- 0x%p (%x bytes)\n\r",
-               initrd_start, (char *)(&__ramdisk_begin), initrd_size);
-        memcpy((char *)initrd_start, (char *)(&__ramdisk_begin), initrd_size);
-    } else
-        a2 = 0xdeadbeef;
-
-    im = (char *)(&__image_begin);
-    len = (char *)(&__image_end) - (char *)(&__image_begin);
-    /* claim 3MB starting at PROG_START */
-    claim(PROG_START, PROG_SIZE, 0);
-    dst = (void *) PROG_START;
-    if (im[0] == 0x1f && im[1] == 0x8b) {
-        /* claim some memory for scratch space */
-        avail_ram = (char *) claim(0, SCRATCH_SIZE, 0x10);
-        begin_avail = avail_high = avail_ram;
-        end_avail = avail_ram + SCRATCH_SIZE;
-        printf("heap at 0x%p\n", avail_ram);
-        printf("gunzipping (0x%p <- 0x%p:0x%p)...", dst, im, im+len);
-        gunzip(dst, PROG_SIZE, im, &len);
-        printf("done %u bytes\n", len);
-        printf("%u bytes of heap consumed, max in use %u\n",
-               avail_high - begin_avail, heap_max);
-        release(begin_avail, SCRATCH_SIZE);
-    } else {
-        memmove(dst, im, len);
-    }
-
-    flush_cache(dst, len);
-    make_bi_recs(((unsigned long) dst + len), "chrpboot", _MACH_Pmac,
-                    (PROG_START + PROG_SIZE));
-
-    sa = (unsigned long)PROG_START;
-    printf("start address = 0x%x\n", sa);
-
-    (*(kernel_start_t)sa)(a1, a2, prom);
-
-    printf("returned?\n");
-
-    pause();
-}
diff --git a/arch/ppc/kernel/Makefile b/arch/ppc/kernel/Makefile
index ca0201300868..e399bbb969a4 100644
--- a/arch/ppc/kernel/Makefile
+++ b/arch/ppc/kernel/Makefile
@@ -9,7 +9,6 @@ extra-$(CONFIG_44x)		:= head_44x.o
 extra-$(CONFIG_FSL_BOOKE)       := head_fsl_booke.o
 extra-$(CONFIG_8xx)             := head_8xx.o
 extra-$(CONFIG_6xx)             += idle_6xx.o
-extra-$(CONFIG_POWER4)          += idle_power4.o
 extra-y                         += vmlinux.lds
 
 obj-y                           := entry.o traps.o idle.o time.o misc.o \
@@ -17,7 +16,6 @@ obj-y				:= entry.o traps.o idle.o time.o misc.o \
                                         ppc_htab.o
 obj-$(CONFIG_6xx)               += l2cr.o cpu_setup_6xx.o
 obj-$(CONFIG_SOFTWARE_SUSPEND)  += swsusp.o
-obj-$(CONFIG_POWER4)            += cpu_setup_power4.o
 obj-$(CONFIG_MODULES)           += module.o ppc_ksyms.o
 obj-$(CONFIG_NOT_COHERENT_CACHE)        += dma-mapping.o
 obj-$(CONFIG_PCI)               += pci.o
@@ -42,7 +40,6 @@ obj-$(CONFIG_6xx)		+= l2cr.o cpu_setup_6xx.o
 obj-$(CONFIG_SOFTWARE_SUSPEND)  += swsusp.o
 obj-$(CONFIG_MODULES)           += module.o
 obj-$(CONFIG_NOT_COHERENT_CACHE)        += dma-mapping.o
-obj-$(CONFIG_PCI)               += pci.o
 obj-$(CONFIG_KGDB)              += ppc-stub.o
 obj-$(CONFIG_TAU)               += temp.o
 ifndef CONFIG_E200
diff --git a/arch/ppc/kernel/head_8xx.S b/arch/ppc/kernel/head_8xx.S
index de0978742221..3e6ca7f5843f 100644
--- a/arch/ppc/kernel/head_8xx.S
+++ b/arch/ppc/kernel/head_8xx.S
@@ -375,6 +375,8 @@ DataStoreTLBMiss:
         lis     r11, swapper_pg_dir@h
         ori     r11, r11, swapper_pg_dir@l
         rlwimi  r10, r11, 0, 2, 19
+        stw     r12, 16(r0)
+        b LoadLargeDTLB
 3:
         lwz     r11, 0(r10)     /* Get the level 1 entry */
         rlwinm. r10, r11,0,0,19 /* Extract page descriptor page address */
@@ -430,6 +432,81 @@ DataStoreTLBMiss:
 InstructionTLBError:
         b       InstructionAccess
 
+LoadLargeDTLB:
+        li      r12, 0
+        lwz     r11, 0(r10)     /* Get the level 1 entry */
+        rlwinm. r10, r11,0,0,19 /* Extract page descriptor page address */
+        beq     3f              /* If zero, don't try to find a pte */
+
+        /* We have a pte table, so load fetch the pte from the table.
+         */
+        ori     r11, r11, 1     /* Set valid bit in physical L2 page */
+        DO_8xx_CPU6(0x3b80, r3)
+        mtspr   SPRN_MD_TWC, r11        /* Load pte table base address */
+        mfspr   r10, SPRN_MD_TWC        /* ....and get the pte address */
+        lwz     r10, 0(r10)     /* Get the pte */
+
+        /* Insert the Guarded flag into the TWC from the Linux PTE.
+         * It is bit 27 of both the Linux PTE and the TWC (at least
+         * I got that right :-).  It will be better when we can put
+         * this into the Linux pgd/pmd and load it in the operation
+         * above.
+         */
+        rlwimi  r11, r10, 0, 27, 27
+
+        rlwimi  r12, r10, 0, 0, 9       /* extract phys. addr */
+        mfspr   r3, SPRN_MD_EPN
+        rlwinm  r3, r3, 0, 0, 9         /* extract virtual address */
+        tophys(r3, r3)
+        cmpw    r3, r12                 /* only use 8M page if it is a direct 
+                                           kernel mapping */
+        bne     1f
+        ori     r11, r11, MD_PS8MEG
+        li      r12, 1
+        b       2f
+1:
+        li      r12, 0          /* can't use 8MB TLB, so zero r12. */
+2:
+        DO_8xx_CPU6(0x3b80, r3)
+        mtspr   SPRN_MD_TWC, r11
+
+        /* The Linux PTE won't go exactly into the MMU TLB.
+         * Software indicator bits 21, 22 and 28 must be clear.
+         * Software indicator bits 24, 25, 26, and 27 must be
+         * set.  All other Linux PTE bits control the behavior
+         * of the MMU.
+         */
+3:      li      r11, 0x00f0
+        rlwimi  r10, r11, 0, 24, 28     /* Set 24-27, clear 28 */
+        cmpwi   r12, 1
+        bne 4f
+        ori     r10, r10, 0x8
+
+        mfspr   r12, SPRN_MD_EPN
+        lis     r3, 0xff80              /* 10-19 must be clear for 8MB TLB */
+        ori     r3, r3, 0x0fff
+        and     r12, r3, r12
+        DO_8xx_CPU6(0x3780, r3)
+        mtspr   SPRN_MD_EPN, r12
+
+        lis     r3, 0xff80              /* 10-19 must be clear for 8MB TLB */
+        ori     r3, r3, 0x0fff
+        and     r10, r3, r10
+4:
+        DO_8xx_CPU6(0x3d80, r3)
+        mtspr   SPRN_MD_RPN, r10        /* Update TLB entry */
+
+        mfspr   r10, SPRN_M_TW  /* Restore registers */
+        lwz     r11, 0(r0)
+        mtcr    r11
+        lwz     r11, 4(r0)
+
+        lwz     r12, 16(r0)
+#ifdef CONFIG_8xx_CPU6
+        lwz     r3, 8(r0)
+#endif
+        rfi
+
 /* This is the data TLB error on the MPC8xx.  This could be due to
  * many reasons, including a dirty update to a pte.  We can catch that
  * one here, but anything else is an error.  First, we track down the
diff --git a/arch/ppc/kernel/misc.S b/arch/ppc/kernel/misc.S
index fb5658bba285..c3427eed8345 100644
--- a/arch/ppc/kernel/misc.S
+++ b/arch/ppc/kernel/misc.S
@@ -204,78 +204,6 @@ _GLOBAL(call_setup_cpu)
         mtctr   r5
         bctr
 
-#if defined(CONFIG_CPU_FREQ_PMAC) && defined(CONFIG_6xx)
-
-/* This gets called by via-pmu.c to switch the PLL selection
- * on 750fx CPU. This function should really be moved to some
- * other place (as most of the cpufreq code in via-pmu
- */
-_GLOBAL(low_choose_750fx_pll)
-        /* Clear MSR:EE */
-        mfmsr   r7
-        rlwinm  r0,r7,0,17,15
-        mtmsr   r0
-
-        /* If switching to PLL1, disable HID0:BTIC */
-        cmplwi  cr0,r3,0
-        beq     1f
-        mfspr   r5,SPRN_HID0
-        rlwinm  r5,r5,0,27,25
-        sync
-        mtspr   SPRN_HID0,r5
-        isync
-        sync
-
-1:
-        /* Calc new HID1 value */
-        mfspr   r4,SPRN_HID1    /* Build a HID1:PS bit from parameter */
-        rlwinm  r5,r3,16,15,15  /* Clear out HID1:PS from value read */
-        rlwinm  r4,r4,0,16,14   /* Could have I used rlwimi here ? */
-        or      r4,r4,r5
-        mtspr   SPRN_HID1,r4
-
-        /* Store new HID1 image */
-        rlwinm  r6,r1,0,0,18
-        lwz     r6,TI_CPU(r6)
-        slwi    r6,r6,2
-        addis   r6,r6,nap_save_hid1@ha
-        stw     r4,nap_save_hid1@l(r6)
-
-        /* If switching to PLL0, enable HID0:BTIC */
-        cmplwi  cr0,r3,0
-        bne     1f
-        mfspr   r5,SPRN_HID0
-        ori     r5,r5,HID0_BTIC
-        sync
-        mtspr   SPRN_HID0,r5
-        isync
-        sync
-
-1:
-        /* Return */
-        mtmsr   r7
-        blr
-
-_GLOBAL(low_choose_7447a_dfs)
-        /* Clear MSR:EE */
-        mfmsr   r7
-        rlwinm  r0,r7,0,17,15
-        mtmsr   r0
-        
-        /* Calc new HID1 value */
-        mfspr   r4,SPRN_HID1
-        insrwi  r4,r3,1,9       /* insert parameter into bit 9 */
-        sync
-        mtspr   SPRN_HID1,r4
-        sync
-        isync
-
-        /* Return */
-        mtmsr   r7
-        blr
-
-#endif /* CONFIG_CPU_FREQ_PMAC && CONFIG_6xx */
-
 /*
  * complement mask on the msr then "or" some values on.
  *     _nmask_and_or_msr(nmask, value_to_or)
diff --git a/arch/ppc/kernel/pci.c b/arch/ppc/kernel/pci.c
index 704c846b2b0f..04d04c5bfdd0 100644
--- a/arch/ppc/kernel/pci.c
+++ b/arch/ppc/kernel/pci.c
@@ -1,5 +1,5 @@
 /*
- * Common pmac/prep/chrp pci routines. -- Cort
+ * Common prep/chrp pci routines. -- Cort
  */
 
 #include <linux/config.h>
@@ -50,8 +50,7 @@ static void fixup_cpc710_pci64(struct pci_dev* dev);
 static u8* pci_to_OF_bus_map;
 #endif
 
-/* By default, we don't re-assign bus numbers. We do this only on
- * some pmacs
+/* By default, we don't re-assign bus numbers.
  */
 int pci_assign_all_buses;
 
@@ -780,17 +779,6 @@ pci_busdev_to_OF_node(struct pci_bus *bus, int devfn)
                 return NULL;
 
         /* Fixup bus number according to what OF think it is. */
-#ifdef CONFIG_PPC_PMAC
-        /* The G5 need a special case here. Basically, we don't remap all
-         * busses on it so we don't create the pci-OF-map. However, we do
-         * remap the AGP bus and so have to deal with it. A future better
-         * fix has to be done by making the remapping per-host and always
-         * filling the pci_to_OF map. --BenH
-         */
-        if (_machine == _MACH_Pmac && busnr >= 0xf0)
-                busnr -= 0xf0;
-        else
-#endif
         if (pci_to_OF_bus_map)
                 busnr = pci_to_OF_bus_map[busnr];
         if (busnr == 0xff)
@@ -1040,216 +1028,6 @@ void pcibios_add_platform_entries(struct pci_dev *pdev)
 }
 
 
-#ifdef CONFIG_PPC_PMAC
-/*
- * This set of routines checks for PCI<->PCI bridges that have closed
- * IO resources and have child devices. It tries to re-open an IO
- * window on them.
- *
- * This is a _temporary_ fix to workaround a problem with Apple's OF
- * closing IO windows on P2P bridges when the OF drivers of cards
- * below this bridge don't claim any IO range (typically ATI or
- * Adaptec).
- *
- * A more complete fix would be to use drivers/pci/setup-bus.c, which
- * involves a working pcibios_fixup_pbus_ranges(), some more care about
- * ordering when creating the host bus resources, and maybe a few more
- * minor tweaks
- */
-
-/* Initialize bridges with base/limit values we have collected */
-static void __init
-do_update_p2p_io_resource(struct pci_bus *bus, int enable_vga)
-{
-        struct pci_dev *bridge = bus->self;
-        struct pci_controller* hose = (struct pci_controller *)bridge->sysdata;
-        u32 l;
-        u16 w;
-        struct resource res;
-
-        if (bus->resource[0] == NULL)
-                return;
-        res = *(bus->resource[0]);
-
-        DBG("Remapping Bus %d, bridge: %s\n", bus->number, pci_name(bridge));
-        res.start -= ((unsigned long) hose->io_base_virt - isa_io_base);
-        res.end -= ((unsigned long) hose->io_base_virt - isa_io_base);
-        DBG("  IO window: %08lx-%08lx\n", res.start, res.end);
-
-        /* Set up the top and bottom of the PCI I/O segment for this bus. */
-        pci_read_config_dword(bridge, PCI_IO_BASE, &l);
-        l &= 0xffff000f;
-        l |= (res.start >> 8) & 0x00f0;
-        l |= res.end & 0xf000;
-        pci_write_config_dword(bridge, PCI_IO_BASE, l);
-
-        if ((l & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
-                l = (res.start >> 16) | (res.end & 0xffff0000);
-                pci_write_config_dword(bridge, PCI_IO_BASE_UPPER16, l);
-        }
-
-        pci_read_config_word(bridge, PCI_COMMAND, &w);
-        w |= PCI_COMMAND_IO;
-        pci_write_config_word(bridge, PCI_COMMAND, w);
-
-#if 0 /* Enabling this causes XFree 4.2.0 to hang during PCI probe */
-        if (enable_vga) {
-                pci_read_config_word(bridge, PCI_BRIDGE_CONTROL, &w);
-                w |= PCI_BRIDGE_CTL_VGA;
-                pci_write_config_word(bridge, PCI_BRIDGE_CONTROL, w);
-        }
-#endif
-}
-
-/* This function is pretty basic and actually quite broken for the
- * general case, it's enough for us right now though. It's supposed
- * to tell us if we need to open an IO range at all or not and what
- * size.
- */
-static int __init
-check_for_io_childs(struct pci_bus *bus, struct resource* res, int *found_vga)
-{
-        struct pci_dev *dev;
-        int     i;
-        int     rc = 0;
-
-#define push_end(res, size) do { unsigned long __sz = (size) ; \
-        res->end = ((res->end + __sz) / (__sz + 1)) * (__sz + 1) + __sz; \
-    } while (0)
-
-        list_for_each_entry(dev, &bus->devices, bus_list) {
-                u16 class = dev->class >> 8;
-
-                if (class == PCI_CLASS_DISPLAY_VGA ||
-                    class == PCI_CLASS_NOT_DEFINED_VGA)
-                        *found_vga = 1;
-                if (class >> 8 == PCI_BASE_CLASS_BRIDGE && dev->subordinate)
-                        rc |= check_for_io_childs(dev->subordinate, res, found_vga);
-                if (class == PCI_CLASS_BRIDGE_CARDBUS)
-                        push_end(res, 0xfff);
-
-                for (i=0; i<PCI_NUM_RESOURCES; i++) {
-                        struct resource *r;
-                        unsigned long r_size;
-
-                        if (dev->class >> 8 == PCI_CLASS_BRIDGE_PCI
-                            && i >= PCI_BRIDGE_RESOURCES)
-                                continue;
-                        r = &dev->resource[i];
-                        r_size = r->end - r->start;
-                        if (r_size < 0xfff)
-                                r_size = 0xfff;
-                        if (r->flags & IORESOURCE_IO && (r_size) != 0) {
-                                rc = 1;
-                                push_end(res, r_size);
-                        }
-                }
-        }
-
-        return rc;
-}
-
-/* Here we scan all P2P bridges of a given level that have a closed
- * IO window. Note that the test for the presence of a VGA card should
- * be improved to take into account already configured P2P bridges,
- * currently, we don't see them and might end up configuring 2 bridges
- * with VGA pass through enabled
- */
-static void __init
-do_fixup_p2p_level(struct pci_bus *bus)
-{
-        struct pci_bus *b;
-        int i, parent_io;
-        int has_vga = 0;
-
-        for (parent_io=0; parent_io<4; parent_io++)
-                if (bus->resource[parent_io]
-                    && bus->resource[parent_io]->flags & IORESOURCE_IO)
-                        break;
-        if (parent_io >= 4)
-                return;
-
-        list_for_each_entry(b, &bus->children, node) {
-                struct pci_dev *d = b->self;
-                struct pci_controller* hose = (struct pci_controller *)d->sysdata;
-                struct resource *res = b->resource[0];
-                struct resource tmp_res;
-                unsigned long max;
-                int found_vga = 0;
-
-                memset(&tmp_res, 0, sizeof(tmp_res));
-                tmp_res.start = bus->resource[parent_io]->start;
-
-                /* We don't let low addresses go through that closed P2P bridge, well,
-                 * that may not be necessary but I feel safer that way
-                 */
-                if (tmp_res.start == 0)
-                        tmp_res.start = 0x1000;
-        
-                if (!list_empty(&b->devices) && res && res->flags == 0 &&
-                    res != bus->resource[parent_io] &&
-                    (d->class >> 8) == PCI_CLASS_BRIDGE_PCI &&
-                    check_for_io_childs(b, &tmp_res, &found_vga)) {
-                        u8 io_base_lo;
-
-                        printk(KERN_INFO "Fixing up IO bus %s\n", b->name);
-
-                        if (found_vga) {
-                                if (has_vga) {
-                                        printk(KERN_WARNING "Skipping VGA, already active"
-                                            " on bus segment\n");
-                                        found_vga = 0;
-                                } else
-                                        has_vga = 1;
-                        }
-                        pci_read_config_byte(d, PCI_IO_BASE, &io_base_lo);
-
-                        if ((io_base_lo & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32)
-                                max = ((unsigned long) hose->io_base_virt
-                                        - isa_io_base) + 0xffffffff;
-                        else
-                                max = ((unsigned long) hose->io_base_virt
-                                        - isa_io_base) + 0xffff;
-
-                        *res = tmp_res;
-                        res->flags = IORESOURCE_IO;
-                        res->name = b->name;
-                
-                        /* Find a resource in the parent where we can allocate */
-                        for (i = 0 ; i < 4; i++) {
-                                struct resource *r = bus->resource[i];
-                                if (!r)
-                                        continue;
-                                if ((r->flags & IORESOURCE_IO) == 0)
-                                        continue;
-                                DBG("Trying to allocate from %08lx, size %08lx from parent"
-                                    " res %d: %08lx -> %08lx\n",
-                                        res->start, res->end, i, r->start, r->end);
-                        
-                                if (allocate_resource(r, res, res->end + 1, res->start, max,
-                                    res->end + 1, NULL, NULL) < 0) {
-                                        DBG("Failed !\n");
-                                        continue;
-                                }
-                                do_update_p2p_io_resource(b, found_vga);
-                                break;
-                        }
-                }
-                do_fixup_p2p_level(b);
-        }
-}
-
-static void
-pcibios_fixup_p2p_bridges(void)
-{
-        struct pci_bus *b;
-
-        list_for_each_entry(b, &pci_root_buses, node)
-                do_fixup_p2p_level(b);
-}
-
-#endif /* CONFIG_PPC_PMAC */
-
 static int __init
 pcibios_init(void)
 {
@@ -1290,9 +1068,6 @@ pcibios_init(void)
         pcibios_allocate_bus_resources(&pci_root_buses);
         pcibios_allocate_resources(0);
         pcibios_allocate_resources(1);
-#ifdef CONFIG_PPC_PMAC
-        pcibios_fixup_p2p_bridges();
-#endif /* CONFIG_PPC_PMAC */
         pcibios_assign_resources();
 
         /* Call machine dependent post-init code */
@@ -1722,17 +1497,6 @@ long sys_pciconfig_iobase(long which, unsigned long bus, unsigned long devfn)
         struct pci_controller* hose;
         long result = -EOPNOTSUPP;
 
-        /* Argh ! Please forgive me for that hack, but that's the
-         * simplest way to get existing XFree to not lockup on some
-         * G5 machines... So when something asks for bus 0 io base
-         * (bus 0 is HT root), we return the AGP one instead.
-         */
-#ifdef CONFIG_PPC_PMAC
-        if (_machine == _MACH_Pmac && machine_is_compatible("MacRISC4"))
-                if (bus == 0)
-                        bus = 0xf0;
-#endif /* CONFIG_PPC_PMAC */
-
         hose = pci_bus_to_hose(bus);
         if (!hose)
                 return -ENODEV;
diff --git a/arch/ppc/kernel/ppc_ksyms.c b/arch/ppc/kernel/ppc_ksyms.c
index 95075f99a6d4..3a6e4bcb3c53 100644
--- a/arch/ppc/kernel/ppc_ksyms.c
+++ b/arch/ppc/kernel/ppc_ksyms.c
@@ -34,7 +34,6 @@
 #include <asm/system.h>
 #include <asm/pci-bridge.h>
 #include <asm/irq.h>
-#include <asm/pmac_feature.h>
 #include <asm/dma.h>
 #include <asm/machdep.h>
 #include <asm/hw_irq.h>
@@ -58,7 +57,6 @@ extern void machine_check_exception(struct pt_regs *regs);
 extern void alignment_exception(struct pt_regs *regs);
 extern void program_check_exception(struct pt_regs *regs);
 extern void single_step_exception(struct pt_regs *regs);
-extern int pmac_newworld;
 extern int sys_sigreturn(struct pt_regs *regs);
 
 long long __ashrdi3(long long, int);
@@ -213,10 +211,6 @@ EXPORT_SYMBOL(adb_try_handler_change);
 EXPORT_SYMBOL(cuda_request);
 EXPORT_SYMBOL(cuda_poll);
 #endif /* CONFIG_ADB_CUDA */
-#ifdef CONFIG_PPC_PMAC
-EXPORT_SYMBOL(sys_ctrler);
-EXPORT_SYMBOL(pmac_newworld);
-#endif
 #ifdef CONFIG_PPC_OF
 EXPORT_SYMBOL(find_devices);
 EXPORT_SYMBOL(find_type_devices);
@@ -241,9 +235,6 @@ EXPORT_SYMBOL(of_node_put);
 #if defined(CONFIG_BOOTX_TEXT)
 EXPORT_SYMBOL(btext_update_display);
 #endif
-#if defined(CONFIG_SCSI) && defined(CONFIG_PPC_PMAC)
-EXPORT_SYMBOL(note_scsi_host);
-#endif
 #ifdef CONFIG_VT
 EXPORT_SYMBOL(kd_mksound);
 #endif
@@ -270,7 +261,6 @@ EXPORT_SYMBOL(__delay);
 EXPORT_SYMBOL(timer_interrupt);
 EXPORT_SYMBOL(irq_desc);
 EXPORT_SYMBOL(tb_ticks_per_jiffy);
-EXPORT_SYMBOL(get_wchan);
 EXPORT_SYMBOL(console_drivers);
 #ifdef CONFIG_XMON
 EXPORT_SYMBOL(xmon);
diff --git a/arch/ppc/kernel/setup.c b/arch/ppc/kernel/setup.c
index e707c6f6e61b..c08ab432e958 100644
--- a/arch/ppc/kernel/setup.c
+++ b/arch/ppc/kernel/setup.c
@@ -1,5 +1,5 @@
 /*
- * Common prep/pmac/chrp boot and setup code.
+ * Common prep/chrp boot and setup code.
  */
 
 #include <linux/config.h>
@@ -35,7 +35,6 @@
 #include <asm/machdep.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
-#include <asm/pmac_feature.h>
 #include <asm/sections.h>
 #include <asm/nvram.h>
 #include <asm/xmon.h>
@@ -55,7 +54,6 @@
 
 extern void platform_init(unsigned long r3, unsigned long r4,
                 unsigned long r5, unsigned long r6, unsigned long r7);
-extern void bootx_init(unsigned long r4, unsigned long phys);
 extern void identify_cpu(unsigned long offset, unsigned long cpu);
 extern void do_cpu_ftr_fixups(unsigned long offset);
 extern void reloc_got2(unsigned long offset);
@@ -80,8 +78,6 @@ EXPORT_SYMBOL(_machine);
 
 extern void prep_init(unsigned long r3, unsigned long r4,
                 unsigned long r5, unsigned long r6, unsigned long r7);
-extern void pmac_init(unsigned long r3, unsigned long r4,
-                unsigned long r5, unsigned long r6, unsigned long r7);
 extern void chrp_init(unsigned long r3, unsigned long r4,
                 unsigned long r5, unsigned long r6, unsigned long r7);
 
@@ -324,20 +320,15 @@ early_init(int r3, int r4, int r5)
         identify_cpu(offset, 0);
         do_cpu_ftr_fixups(offset);
 
-#if defined(CONFIG_PPC_MULTIPLATFORM)
+#if defined(CONFIG_PPC_OF)
         reloc_got2(offset);
 
-        /* If we came here from BootX, clear the screen,
-         * set up some pointers and return. */
-        if ((r3 == 0x426f6f58) && (r5 == 0))
-                bootx_init(r4, phys);
-
         /*
          * don't do anything on prep
          * for now, don't use bootinfo because it breaks yaboot 0.5
          * and assume that if we didn't find a magic number, we have OF
          */
-        else if (*(unsigned long *)(0) != 0xdeadc0de)
+        if (*(unsigned long *)(0) != 0xdeadc0de)
                 phys = prom_init(r3, r4, (prom_entry)r5);
 
         reloc_got2(-offset);
@@ -424,6 +415,7 @@ platform_init(unsigned long r3, unsigned long r4, unsigned long r5,
         }
 #endif
 
+#ifdef CONFIG_PPC_OF
         have_of = 1;
 
         /* prom_init has already been called from __start */
@@ -495,19 +487,17 @@ platform_init(unsigned long r3, unsigned long r4, unsigned long r5,
 #endif /* CONFIG_ADB */
 
         switch (_machine) {
-#ifdef CONFIG_PPC_PMAC
-        case _MACH_Pmac:
-                pmac_init(r3, r4, r5, r6, r7);
-                break;
-#endif
 #ifdef CONFIG_PPC_CHRP
         case _MACH_chrp:
                 chrp_init(r3, r4, r5, r6, r7);
                 break;
 #endif
         }
+#endif /* CONFIG_PPC_OF */
 }
+#endif /* CONFIG_PPC_MULTIPLATFORM */
 
+#ifdef CONFIG_PPC_OF
 #ifdef CONFIG_SERIAL_CORE_CONSOLE
 extern char *of_stdout_device;
 
@@ -564,7 +554,7 @@ static int __init set_preferred_console(void)
 }
 console_initcall(set_preferred_console);
 #endif /* CONFIG_SERIAL_CORE_CONSOLE */
-#endif /* CONFIG_PPC_MULTIPLATFORM */
+#endif /* CONFIG_PPC_OF */
 
 struct bi_record *find_bootinfo(void)
 {
@@ -747,14 +737,6 @@ void __init setup_arch(char **cmdline_p)
         if (ppc_md.init_early)
                 ppc_md.init_early();
 
-#ifdef CONFIG_PPC_MULTIPLATFORM
-        /* This could be called "early setup arch", it must be done
-         * now because xmon need it
-         */
-        if (_machine == _MACH_Pmac)
-                pmac_feature_init();    /* New cool way */
-#endif
-
 #ifdef CONFIG_XMON
         xmon_init(1);
         if (strstr(cmd_line, "xmon"))
diff --git a/arch/ppc/kernel/traps.c b/arch/ppc/kernel/traps.c
index 9dbc4d28fa28..6d0a1838d94c 100644
--- a/arch/ppc/kernel/traps.c
+++ b/arch/ppc/kernel/traps.c
@@ -38,9 +38,6 @@
 #include <asm/io.h>
 #include <asm/reg.h>
 #include <asm/xmon.h>
-#ifdef CONFIG_PMAC_BACKLIGHT
-#include <asm/backlight.h>
-#endif
 #include <asm/pmc.h>
 
 #ifdef CONFIG_XMON
@@ -85,12 +82,6 @@ int die(const char * str, struct pt_regs * fp, long err)
         int nl = 0;
         console_verbose();
         spin_lock_irq(&die_lock);
-#ifdef CONFIG_PMAC_BACKLIGHT
-        if (_machine == _MACH_Pmac) {
-                set_backlight_enable(1);
-                set_backlight_level(BACKLIGHT_MAX);
-        }
-#endif
         printk("Oops: %s, sig: %ld [#%d]\n", str, err, ++die_counter);
 #ifdef CONFIG_PREEMPT
         printk("PREEMPT ");
@@ -159,7 +150,7 @@ void _exception(int signr, struct pt_regs *regs, int code, unsigned long addr)
  */
 static inline int check_io_access(struct pt_regs *regs)
 {
-#if defined CONFIG_PPC_PMAC || defined CONFIG_8xx
+#if defined CONFIG_8xx
         unsigned long msr = regs->msr;
         const struct exception_table_entry *entry;
         unsigned int *nip = (unsigned int *)regs->nip;
@@ -196,7 +187,7 @@ static inline int check_io_access(struct pt_regs *regs)
                         return 1;
                 }
         }
-#endif /* CONFIG_PPC_PMAC */
+#endif /* CONFIG_8xx */
         return 0;
 }
 
diff --git a/arch/ppc/mm/init.c b/arch/ppc/mm/init.c
index 45f0782059f1..134db5c04203 100644
--- a/arch/ppc/mm/init.c
+++ b/arch/ppc/mm/init.c
@@ -67,10 +67,6 @@ unsigned long ppc_memoffset = PAGE_OFFSET;
 int mem_init_done;
 int init_bootmem_done;
 int boot_mapsize;
-#ifdef CONFIG_PPC_PMAC
-unsigned long agp_special_page;
-EXPORT_SYMBOL(agp_special_page);
-#endif
 
 extern char _end[];
 extern char etext[], _stext[];
@@ -424,10 +420,6 @@ void __init mem_init(void)
                      addr += PAGE_SIZE)
                         SetPageReserved(virt_to_page(addr));
 #endif
-#ifdef CONFIG_PPC_PMAC
-        if (agp_special_page)
-                SetPageReserved(virt_to_page(agp_special_page));
-#endif
         for (addr = PAGE_OFFSET; addr < (unsigned long)high_memory;
              addr += PAGE_SIZE) {
                 if (!PageReserved(virt_to_page(addr)))
@@ -463,11 +455,6 @@ void __init mem_init(void)
                initpages<< (PAGE_SHIFT-10),
                (unsigned long) (totalhigh_pages << (PAGE_SHIFT-10)));
 
-#ifdef CONFIG_PPC_PMAC
-        if (agp_special_page)
-                printk(KERN_INFO "AGP special page: 0x%08lx\n", agp_special_page);
-#endif
-
         mem_init_done = 1;
 }
 
@@ -512,22 +499,6 @@ set_phys_avail(unsigned long total_memory)
         if (rtas_data)
                 mem_pieces_remove(&phys_avail, rtas_data, rtas_size, 1);
 #endif
-#ifdef CONFIG_PPC_PMAC
-        /* Because of some uninorth weirdness, we need a page of
-         * memory as high as possible (it must be outside of the
-         * bus address seen as the AGP aperture). It will be used
-         * by the r128 DRM driver
-         *
-         * FIXME: We need to make sure that page doesn't overlap any of the\
-         * above. This could be done by improving mem_pieces_find to be able
-         * to do a backward search from the end of the list.
-         */
-        if (_machine == _MACH_Pmac && find_devices("uni-north-agp")) {
-                agp_special_page = (total_memory - PAGE_SIZE);
-                mem_pieces_remove(&phys_avail, agp_special_page, PAGE_SIZE, 0);
-                agp_special_page = (unsigned long)__va(agp_special_page);
-        }
-#endif /* CONFIG_PPC_PMAC */
 }
 
 /* Mark some memory as reserved by removing it from phys_avail. */
diff --git a/arch/ppc/platforms/83xx/mpc834x_sys.c b/arch/ppc/platforms/83xx/mpc834x_sys.c
index 04bdc39bf47b..012e1e652c03 100644
--- a/arch/ppc/platforms/83xx/mpc834x_sys.c
+++ b/arch/ppc/platforms/83xx/mpc834x_sys.c
@@ -51,9 +51,6 @@
 
 #include <syslib/ppc83xx_setup.h>
 
-static const char *GFAR_PHY_0 = "phy0:0";
-static const char *GFAR_PHY_1 = "phy0:1";
-
 #ifndef CONFIG_PCI
 unsigned long isa_io_base = 0;
 unsigned long isa_mem_base = 0;
@@ -129,20 +126,21 @@ mpc834x_sys_setup_arch(void)
         mdata->irq[1] = MPC83xx_IRQ_EXT2;
         mdata->irq[2] = -1;
         mdata->irq[31] = -1;
-        mdata->paddr += binfo->bi_immr_base;
 
         /* setup the board related information for the enet controllers */
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC83xx_TSEC1);
         if (pdata) {
                 pdata->board_flags = FSL_GIANFAR_BRD_HAS_PHY_INTR;
-                pdata->bus_id = GFAR_PHY_0;
+                pdata->bus_id = 0;
+                pdata->phy_id = 0;
                 memcpy(pdata->mac_addr, binfo->bi_enetaddr, 6);
         }
 
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC83xx_TSEC2);
         if (pdata) {
                 pdata->board_flags = FSL_GIANFAR_BRD_HAS_PHY_INTR;
-                pdata->bus_id = GFAR_PHY_1;
+                pdata->bus_id = 0;
+                pdata->phy_id = 1;
                 memcpy(pdata->mac_addr, binfo->bi_enet1addr, 6);
         }
 
diff --git a/arch/ppc/platforms/85xx/mpc8540_ads.c b/arch/ppc/platforms/85xx/mpc8540_ads.c
index c5cde97c6ef0..2eceb1e6f4eb 100644
--- a/arch/ppc/platforms/85xx/mpc8540_ads.c
+++ b/arch/ppc/platforms/85xx/mpc8540_ads.c
@@ -52,10 +52,6 @@
 
 #include <syslib/ppc85xx_setup.h>
 
-static const char *GFAR_PHY_0 = "phy0:0";
-static const char *GFAR_PHY_1 = "phy0:1";
-static const char *GFAR_PHY_3 = "phy0:3";
-
 /* ************************************************************************
  *
  * Setup the architecture
@@ -102,27 +98,29 @@ mpc8540ads_setup_arch(void)
         mdata->irq[2] = -1;
         mdata->irq[3] = MPC85xx_IRQ_EXT5;
         mdata->irq[31] = -1;
-        mdata->paddr += binfo->bi_immr_base;
 
         /* setup the board related information for the enet controllers */
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC85xx_TSEC1);
         if (pdata) {
                 pdata->board_flags = FSL_GIANFAR_BRD_HAS_PHY_INTR;
-                pdata->bus_id = GFAR_PHY_0;
+                pdata->bus_id = 0;
+                pdata->phy_id = 0;
                 memcpy(pdata->mac_addr, binfo->bi_enetaddr, 6);
         }
 
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC85xx_TSEC2);
         if (pdata) {
                 pdata->board_flags = FSL_GIANFAR_BRD_HAS_PHY_INTR;
-                pdata->bus_id = GFAR_PHY_1;
+                pdata->bus_id = 0;
+                pdata->phy_id = 1;
                 memcpy(pdata->mac_addr, binfo->bi_enet1addr, 6);
         }
 
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC85xx_FEC);
         if (pdata) {
                 pdata->board_flags = 0;
-                pdata->bus_id = GFAR_PHY_3;
+                pdata->bus_id = 0;
+                pdata->phy_id = 3;
                 memcpy(pdata->mac_addr, binfo->bi_enet2addr, 6);
         }
 
diff --git a/arch/ppc/platforms/85xx/mpc8560_ads.c b/arch/ppc/platforms/85xx/mpc8560_ads.c
index 8e39a5517092..442c7ff195d3 100644
--- a/arch/ppc/platforms/85xx/mpc8560_ads.c
+++ b/arch/ppc/platforms/85xx/mpc8560_ads.c
@@ -56,10 +56,6 @@
 #include <syslib/ppc85xx_setup.h>
 
 
-static const char *GFAR_PHY_0 = "phy0:0";
-static const char *GFAR_PHY_1 = "phy0:1";
-static const char *GFAR_PHY_3 = "phy0:3";
-
 /* ************************************************************************
  *
  * Setup the architecture
@@ -99,20 +95,21 @@ mpc8560ads_setup_arch(void)
         mdata->irq[2] = -1;
         mdata->irq[3] = MPC85xx_IRQ_EXT5;
         mdata->irq[31] = -1;
-        mdata->paddr += binfo->bi_immr_base;
 
         /* setup the board related information for the enet controllers */
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC85xx_TSEC1);
         if (pdata) {
                 pdata->board_flags = FSL_GIANFAR_BRD_HAS_PHY_INTR;
-                pdata->bus_id = GFAR_PHY_0;
+                pdata->bus_id = 0;
+                pdata->phy_id = 0;
                 memcpy(pdata->mac_addr, binfo->bi_enetaddr, 6);
         }
 
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC85xx_TSEC2);
         if (pdata) {
                 pdata->board_flags = FSL_GIANFAR_BRD_HAS_PHY_INTR;
-                pdata->bus_id = GFAR_PHY_1;
+                pdata->bus_id = 0;
+                pdata->phy_id = 1;
                 memcpy(pdata->mac_addr, binfo->bi_enet1addr, 6);
         }
 
diff --git a/arch/ppc/platforms/85xx/mpc85xx_cds_common.c b/arch/ppc/platforms/85xx/mpc85xx_cds_common.c
index 2959e3c4083d..b332ebae6bd3 100644
--- a/arch/ppc/platforms/85xx/mpc85xx_cds_common.c
+++ b/arch/ppc/platforms/85xx/mpc85xx_cds_common.c
@@ -395,9 +395,6 @@ mpc85xx_cds_pcibios_fixup(void)
 
 TODC_ALLOC();
 
-static const char *GFAR_PHY_0 = "phy0:0";
-static const char *GFAR_PHY_1 = "phy0:1";
-
 /* ************************************************************************
  *
  * Setup the architecture
@@ -461,34 +458,37 @@ mpc85xx_cds_setup_arch(void)
         mdata->irq[2] = -1;
         mdata->irq[3] = -1;
         mdata->irq[31] = -1;
-        mdata->paddr += binfo->bi_immr_base;
 
         /* setup the board related information for the enet controllers */
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC85xx_TSEC1);
         if (pdata) {
                 pdata->board_flags = FSL_GIANFAR_BRD_HAS_PHY_INTR;
-                pdata->bus_id = GFAR_PHY_0;
+                pdata->bus_id = 0;
+                pdata->phy_id = 0;
                 memcpy(pdata->mac_addr, binfo->bi_enetaddr, 6);
         }
 
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC85xx_TSEC2);
         if (pdata) {
                 pdata->board_flags = FSL_GIANFAR_BRD_HAS_PHY_INTR;
-                pdata->bus_id = GFAR_PHY_1;
+                pdata->bus_id = 0;
+                pdata->phy_id = 1;
                 memcpy(pdata->mac_addr, binfo->bi_enet1addr, 6);
         }
 
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC85xx_eTSEC1);
         if (pdata) {
                 pdata->board_flags = FSL_GIANFAR_BRD_HAS_PHY_INTR;
-                pdata->bus_id = GFAR_PHY_0;
+                pdata->bus_id = 0;
+                pdata->phy_id = 0;
                 memcpy(pdata->mac_addr, binfo->bi_enetaddr, 6);
         }
 
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC85xx_eTSEC2);
         if (pdata) {
                 pdata->board_flags = FSL_GIANFAR_BRD_HAS_PHY_INTR;
-                pdata->bus_id = GFAR_PHY_1;
+                pdata->bus_id = 0;
+                pdata->phy_id = 1;
                 memcpy(pdata->mac_addr, binfo->bi_enet1addr, 6);
         }
 
diff --git a/arch/ppc/platforms/85xx/sbc8560.c b/arch/ppc/platforms/85xx/sbc8560.c
index 45a5b81b4ed1..e777ba824aa9 100644
--- a/arch/ppc/platforms/85xx/sbc8560.c
+++ b/arch/ppc/platforms/85xx/sbc8560.c
@@ -91,9 +91,6 @@ sbc8560_early_serial_map(void)
 }
 #endif
 
-static const char *GFAR_PHY_25 = "phy0:25";
-static const char *GFAR_PHY_26 = "phy0:26";
-
 /* ************************************************************************
  *
  * Setup the architecture
@@ -136,20 +133,21 @@ sbc8560_setup_arch(void)
         mdata->irq[25] = MPC85xx_IRQ_EXT6;
         mdata->irq[26] = MPC85xx_IRQ_EXT7;
         mdata->irq[31] = -1;
-        mdata->paddr += binfo->bi_immr_base;
 
         /* setup the board related information for the enet controllers */
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC85xx_TSEC1);
         if (pdata) {
                 pdata->board_flags = FSL_GIANFAR_BRD_HAS_PHY_INTR;
-                pdata->bus_id = GFAR_PHY_25;
+                pdata->bus_id = 0;
+                pdata->phy_id = 25;
                 memcpy(pdata->mac_addr, binfo->bi_enetaddr, 6);
         }
 
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC85xx_TSEC2);
         if (pdata) {
                 pdata->board_flags = FSL_GIANFAR_BRD_HAS_PHY_INTR;
-                pdata->bus_id = GFAR_PHY_26;
+                pdata->bus_id = 0;
+                pdata->phy_id = 26;
                 memcpy(pdata->mac_addr, binfo->bi_enet1addr, 6);
         }
 
diff --git a/arch/ppc/platforms/85xx/stx_gp3.c b/arch/ppc/platforms/85xx/stx_gp3.c
index 15ce9d070634..061bb7cf2d9a 100644
--- a/arch/ppc/platforms/85xx/stx_gp3.c
+++ b/arch/ppc/platforms/85xx/stx_gp3.c
@@ -93,9 +93,6 @@ static u8 gp3_openpic_initsenses[] __initdata = {
         0x0,                            /* External 11: */
 };
 
-static const char *GFAR_PHY_2 = "phy0:2";
-static const char *GFAR_PHY_4 = "phy0:4";
-
 /*
  * Setup the architecture
  */
@@ -130,20 +127,21 @@ gp3_setup_arch(void)
         mdata->irq[2] = MPC85xx_IRQ_EXT5;
         mdata->irq[4] = MPC85xx_IRQ_EXT5;
         mdata->irq[31] = -1;
-        mdata->paddr += binfo->bi_immr_base;
 
         /* setup the board related information for the enet controllers */
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC85xx_TSEC1);
         if (pdata) {
         /*      pdata->board_flags = FSL_GIANFAR_BRD_HAS_PHY_INTR; */
-                pdata->bus_id = GFAR_PHY_2;
+                pdata->bus_id = 0;
+                pdata->phy_id = 2;
                 memcpy(pdata->mac_addr, binfo->bi_enetaddr, 6);
         }
 
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC85xx_TSEC2);
         if (pdata) {
         /*      pdata->board_flags = FSL_GIANFAR_BRD_HAS_PHY_INTR; */
-                pdata->bus_id = GFAR_PHY_4;
+                pdata->bus_id = 0;
+                pdata->phy_id = 4;
                 memcpy(pdata->mac_addr, binfo->bi_enet1addr, 6);
         }
 
diff --git a/arch/ppc/platforms/85xx/tqm85xx.c b/arch/ppc/platforms/85xx/tqm85xx.c
index c6dfd8f0f9df..b436f4d0a3fa 100644
--- a/arch/ppc/platforms/85xx/tqm85xx.c
+++ b/arch/ppc/platforms/85xx/tqm85xx.c
@@ -91,12 +91,6 @@ static u_char tqm85xx_openpic_initsenses[] __initdata = {
         0x0,                            /* External 11: */
 };
 
-static const char *GFAR_PHY_0 = "phy0:2";
-static const char *GFAR_PHY_1 = "phy0:1";
-#ifdef CONFIG_MPC8540
-static const char *GFAR_PHY_3 = "phy0:3";
-#endif
-
 /* ************************************************************************
  *
  * Setup the architecture
@@ -149,20 +143,21 @@ tqm85xx_setup_arch(void)
         mdata->irq[2] = -1;
         mdata->irq[3] = MPC85xx_IRQ_EXT8;
         mdata->irq[31] = -1;
-        mdata->paddr += binfo->bi_immr_base;
 
         /* setup the board related information for the enet controllers */
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC85xx_TSEC1);
         if (pdata) {
                 pdata->board_flags = FSL_GIANFAR_BRD_HAS_PHY_INTR;
-                pdata->bus_id = GFAR_PHY_0;
+                pdata->bus_id = 0;
+                pdata->phy_id = 2;
                 memcpy(pdata->mac_addr, binfo->bi_enetaddr, 6);
         }
 
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC85xx_TSEC2);
         if (pdata) {
                 pdata->board_flags = FSL_GIANFAR_BRD_HAS_PHY_INTR;
-                pdata->bus_id = GFAR_PHY_1;
+                pdata->bus_id = 0;
+                pdata->phy_id = 1;
                 memcpy(pdata->mac_addr, binfo->bi_enet1addr, 6);
         }
 
@@ -170,7 +165,8 @@ tqm85xx_setup_arch(void)
         pdata = (struct gianfar_platform_data *) ppc_sys_get_pdata(MPC85xx_FEC);
         if (pdata) {
                 pdata->board_flags = 0;
-                pdata->bus_id = GFAR_PHY_3;
+                pdata->bus_id = 0;
+                pdata->phy_id = 3;
                 memcpy(pdata->mac_addr, binfo->bi_enet2addr, 6);
         }
 #endif
diff --git a/arch/ppc/platforms/Makefile b/arch/ppc/platforms/Makefile
index 7c5cdabf6f3c..51430e294b32 100644
--- a/arch/ppc/platforms/Makefile
+++ b/arch/ppc/platforms/Makefile
@@ -3,26 +3,18 @@
 #
 
 # Extra CFLAGS so we don't have to do relative includes
-CFLAGS_pmac_setup.o     += -Iarch/$(ARCH)/mm
+CFLAGS_chrp_setup.o     += -Iarch/$(ARCH)/mm
 
 obj-$(CONFIG_APUS)              += apus_setup.o
 ifeq ($(CONFIG_APUS),y)
 obj-$(CONFIG_PCI)               += apus_pci.o
 endif
-obj-$(CONFIG_PPC_PMAC)          += pmac_pic.o pmac_setup.o pmac_time.o \
-                                        pmac_feature.o pmac_pci.o pmac_sleep.o \
-                                        pmac_low_i2c.o pmac_cache.o
 obj-$(CONFIG_PPC_CHRP)          += chrp_setup.o chrp_time.o chrp_pci.o \
                                         chrp_pegasos_eth.o
 ifeq ($(CONFIG_PPC_CHRP),y)
 obj-$(CONFIG_NVRAM)             += chrp_nvram.o
 endif
 obj-$(CONFIG_PPC_PREP)          += prep_pci.o prep_setup.o
-ifeq ($(CONFIG_PPC_PMAC),y)
-obj-$(CONFIG_NVRAM)             += pmac_nvram.o
-obj-$(CONFIG_CPU_FREQ_PMAC)     += pmac_cpufreq.o
-endif
-obj-$(CONFIG_PMAC_BACKLIGHT)    += pmac_backlight.o
 obj-$(CONFIG_PREP_RESIDUAL)     += residual.o
 obj-$(CONFIG_PQ2ADS)            += pq2ads.o
 obj-$(CONFIG_TQM8260)           += tqm8260_setup.o
@@ -47,6 +39,5 @@ obj-$(CONFIG_LITE5200)		+= lite5200.o
 obj-$(CONFIG_EV64360)           += ev64360.o
 
 ifeq ($(CONFIG_SMP),y)
-obj-$(CONFIG_PPC_PMAC)          += pmac_smp.o
 obj-$(CONFIG_PPC_CHRP)          += chrp_smp.o
 endif
diff --git a/arch/ppc/platforms/chrp_pci.c b/arch/ppc/platforms/chrp_pci.c
index bd047aac01b1..c7fe6182bb77 100644
--- a/arch/ppc/platforms/chrp_pci.c
+++ b/arch/ppc/platforms/chrp_pci.c
@@ -275,7 +275,7 @@ chrp_find_bridges(void)
                         setup_python(hose, dev);
                 } else if (is_mot
                            || strncmp(model, "Motorola, Grackle", 17) == 0) {
-                        setup_grackle(hose);
+                        setup_indirect_pci(hose, 0xfec00000, 0xfee00000);
                 } else if (is_longtrail) {
                         void __iomem *p = ioremap(GG2_PCI_CONFIG_BASE, 0x80000);
                         hose->ops = &gg2_pci_ops;
diff --git a/arch/ppc/platforms/chrp_setup.c b/arch/ppc/platforms/chrp_setup.c
index 056ac2a7b5c1..48996b787378 100644
--- a/arch/ppc/platforms/chrp_setup.c
+++ b/arch/ppc/platforms/chrp_setup.c
@@ -53,6 +53,7 @@
 #include <asm/i8259.h>
 #include <asm/open_pic.h>
 #include <asm/xmon.h>
+#include "mem_pieces.h"
 
 unsigned long chrp_get_rtc_time(void);
 int chrp_set_rtc_time(unsigned long nowtime);
@@ -65,7 +66,6 @@ void rtas_display_progress(char *, unsigned short);
 void rtas_indicator_progress(char *, unsigned short);
 void btext_progress(char *, unsigned short);
 
-extern unsigned long pmac_find_end_of_memory(void);
 extern int of_show_percpuinfo(struct seq_file *, int);
 
 int _chrp_type;
@@ -467,6 +467,75 @@ chrp_init2(void)
                 ppc_md.progress("  Have fun!    ", 0x7777);
 }
 
+static struct device_node *memory_node;
+
+static int __init get_mem_prop(char *name, struct mem_pieces *mp)
+{
+        struct reg_property *rp;
+        int i, s;
+        unsigned int *ip;
+        int nac = prom_n_addr_cells(memory_node);
+        int nsc = prom_n_size_cells(memory_node);
+
+        ip = (unsigned int *) get_property(memory_node, name, &s);
+        if (ip == NULL) {
+                printk(KERN_ERR "error: couldn't get %s property on /memory\n",
+                       name);
+                return 0;
+        }
+        s /= (nsc + nac) * 4;
+        rp = mp->regions;
+        for (i = 0; i < s; ++i, ip += nac+nsc) {
+                if (nac >= 2 && ip[nac-2] != 0)
+                        continue;
+                rp->address = ip[nac-1];
+                if (nsc >= 2 && ip[nac+nsc-2] != 0)
+                        rp->size = ~0U;
+                else
+                        rp->size = ip[nac+nsc-1];
+                ++rp;
+        }
+        mp->n_regions = rp - mp->regions;
+
+        /* Make sure the pieces are sorted. */
+        mem_pieces_sort(mp);
+        mem_pieces_coalesce(mp);
+        return 1;
+}
+
+static unsigned long __init chrp_find_end_of_memory(void)
+{
+        unsigned long a, total;
+        struct mem_pieces phys_mem;
+
+        /*
+         * Find out where physical memory is, and check that it
+         * starts at 0 and is contiguous.  It seems that RAM is
+         * always physically contiguous on Power Macintoshes.
+         *
+         * Supporting discontiguous physical memory isn't hard,
+         * it just makes the virtual <-> physical mapping functions
+         * more complicated (or else you end up wasting space
+         * in mem_map).
+         */
+        memory_node = find_devices("memory");
+        if (memory_node == NULL || !get_mem_prop("reg", &phys_mem)
+            || phys_mem.n_regions == 0)
+                panic("No RAM??");
+        a = phys_mem.regions[0].address;
+        if (a != 0)
+                panic("RAM doesn't start at physical address 0");
+        total = phys_mem.regions[0].size;
+
+        if (phys_mem.n_regions > 1) {
+                printk("RAM starting at 0x%x is not contiguous\n",
+                       phys_mem.regions[1].address);
+                printk("Using RAM from 0 to 0x%lx\n", total-1);
+        }
+
+        return total;
+}
+
 void __init
 chrp_init(unsigned long r3, unsigned long r4, unsigned long r5,
           unsigned long r6, unsigned long r7)
@@ -525,7 +594,7 @@ chrp_init(unsigned long r3, unsigned long r4, unsigned long r5,
         ppc_md.get_rtc_time   = chrp_get_rtc_time;
         ppc_md.calibrate_decr = chrp_calibrate_decr;
 
-        ppc_md.find_end_of_memory = pmac_find_end_of_memory;
+        ppc_md.find_end_of_memory = chrp_find_end_of_memory;
 
         if (rtas_data) {
                 struct device_node *rtas;
diff --git a/arch/ppc/platforms/chrp_time.c b/arch/ppc/platforms/chrp_time.c
index 29d074c305f0..57753a55b580 100644
--- a/arch/ppc/platforms/chrp_time.c
+++ b/arch/ppc/platforms/chrp_time.c
@@ -163,13 +163,75 @@ unsigned long chrp_get_rtc_time(void)
         return mktime(year, mon, day, hour, min, sec);
 }
 
+/*
+ * Calibrate the decrementer frequency with the VIA timer 1.
+ */
+#define VIA_TIMER_FREQ_6        4700000 /* time 1 frequency * 6 */
+
+/* VIA registers */
+#define RS              0x200           /* skip between registers */
+#define T1CL            (4*RS)          /* Timer 1 ctr/latch (low 8 bits) */
+#define T1CH            (5*RS)          /* Timer 1 counter (high 8 bits) */
+#define T1LL            (6*RS)          /* Timer 1 latch (low 8 bits) */
+#define T1LH            (7*RS)          /* Timer 1 latch (high 8 bits) */
+#define ACR             (11*RS)         /* Auxiliary control register */
+#define IFR             (13*RS)         /* Interrupt flag register */
+
+/* Bits in ACR */
+#define T1MODE          0xc0            /* Timer 1 mode */
+#define T1MODE_CONT     0x40            /*  continuous interrupts */
+
+/* Bits in IFR and IER */
+#define T1_INT          0x40            /* Timer 1 interrupt */
+
+static int __init chrp_via_calibrate_decr(void)
+{
+        struct device_node *vias;
+        volatile unsigned char __iomem *via;
+        int count = VIA_TIMER_FREQ_6 / 100;
+        unsigned int dstart, dend;
+
+        vias = find_devices("via-cuda");
+        if (vias == 0)
+                vias = find_devices("via");
+        if (vias == 0 || vias->n_addrs == 0)
+                return 0;
+        via = ioremap(vias->addrs[0].address, vias->addrs[0].size);
+
+        /* set timer 1 for continuous interrupts */
+        out_8(&via[ACR], (via[ACR] & ~T1MODE) | T1MODE_CONT);
+        /* set the counter to a small value */
+        out_8(&via[T1CH], 2);
+        /* set the latch to `count' */
+        out_8(&via[T1LL], count);
+        out_8(&via[T1LH], count >> 8);
+        /* wait until it hits 0 */
+        while ((in_8(&via[IFR]) & T1_INT) == 0)
+                ;
+        dstart = get_dec();
+        /* clear the interrupt & wait until it hits 0 again */
+        in_8(&via[T1CL]);
+        while ((in_8(&via[IFR]) & T1_INT) == 0)
+                ;
+        dend = get_dec();
+
+        tb_ticks_per_jiffy = (dstart - dend) / ((6 * HZ)/100);
+        tb_to_us = mulhwu_scale_factor(dstart - dend, 60000);
+
+        printk(KERN_INFO "via_calibrate_decr: ticks per jiffy = %u (%u ticks)\n",
+               tb_ticks_per_jiffy, dstart - dend);
+
+        iounmap(via);
+        
+        return 1;
+}
 
 void __init chrp_calibrate_decr(void)
 {
         struct device_node *cpu;
         unsigned int freq, *fp;
 
-        if (via_calibrate_decr())
+        if (chrp_via_calibrate_decr())
                 return;
 
         /*
diff --git a/arch/ppc/platforms/pmac_backlight.c b/arch/ppc/platforms/pmac_backlight.c
deleted file mode 100644
index 8be2f7d071f0..000000000000
--- a/arch/ppc/platforms/pmac_backlight.c
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
- * Miscellaneous procedures for dealing with the PowerMac hardware.
- * Contains support for the backlight.
- *
- *   Copyright (C) 2000 Benjamin Herrenschmidt
- *
- */
-
-#include <linux/config.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/stddef.h>
-#include <linux/reboot.h>
-#include <linux/nvram.h>
-#include <linux/console.h>
-#include <asm/sections.h>
-#include <asm/ptrace.h>
-#include <asm/io.h>
-#include <asm/pgtable.h>
-#include <asm/system.h>
-#include <asm/prom.h>
-#include <asm/machdep.h>
-#include <asm/nvram.h>
-#include <asm/backlight.h>
-
-#include <linux/adb.h>
-#include <linux/pmu.h>
-
-static struct backlight_controller *backlighter;
-static void* backlighter_data;
-static int backlight_autosave;
-static int backlight_level = BACKLIGHT_MAX;
-static int backlight_enabled = 1;
-static int backlight_req_level = -1;
-static int backlight_req_enable = -1;
-
-static void backlight_callback(void *);
-static DECLARE_WORK(backlight_work, backlight_callback, NULL);
-
-void register_backlight_controller(struct backlight_controller *ctrler,
-                                          void *data, char *type)
-{
-        struct device_node* bk_node;
-        char *prop;
-        int valid = 0;
-
-        /* There's already a matching controller, bail out */
-        if (backlighter != NULL)
-                return;
-
-        bk_node = find_devices("backlight");
-
-#ifdef CONFIG_ADB_PMU
-        /* Special case for the old PowerBook since I can't test on it */
-        backlight_autosave = machine_is_compatible("AAPL,3400/2400")
-                || machine_is_compatible("AAPL,3500");
-        if ((backlight_autosave
-             || machine_is_compatible("AAPL,PowerBook1998")
-             || machine_is_compatible("PowerBook1,1"))
-            && !strcmp(type, "pmu"))
-                valid = 1;
-#endif
-        if (bk_node) {
-                prop = get_property(bk_node, "backlight-control", NULL);
-                if (prop && !strncmp(prop, type, strlen(type)))
-                        valid = 1;
-        }
-        if (!valid)
-                return;
-        backlighter = ctrler;
-        backlighter_data = data;
-
-        if (bk_node && !backlight_autosave)
-                prop = get_property(bk_node, "bklt", NULL);
-        else
-                prop = NULL;
-        if (prop) {
-                backlight_level = ((*prop)+1) >> 1;
-                if (backlight_level > BACKLIGHT_MAX)
-                        backlight_level = BACKLIGHT_MAX;
-        }
-
-#ifdef CONFIG_ADB_PMU
-        if (backlight_autosave) {
-                struct adb_request req;
-                pmu_request(&req, NULL, 2, 0xd9, 0);
-                while (!req.complete)
-                        pmu_poll();
-                backlight_level = req.reply[0] >> 4;
-        }
-#endif
-        acquire_console_sem();
-        if (!backlighter->set_enable(1, backlight_level, data))
-                backlight_enabled = 1;
-        release_console_sem();
-
-        printk(KERN_INFO "Registered \"%s\" backlight controller,"
-               "level: %d/15\n", type, backlight_level);
-}
-EXPORT_SYMBOL(register_backlight_controller);
-
-void unregister_backlight_controller(struct backlight_controller
-                                            *ctrler, void *data)
-{
-        /* We keep the current backlight level (for now) */
-        if (ctrler == backlighter && data == backlighter_data)
-                backlighter = NULL;
-}
-EXPORT_SYMBOL(unregister_backlight_controller);
-
-static int __set_backlight_enable(int enable)
-{
-        int rc;
-
-        if (!backlighter)
-                return -ENODEV;
-        acquire_console_sem();
-        rc = backlighter->set_enable(enable, backlight_level,
-                                     backlighter_data);
-        if (!rc)
-                backlight_enabled = enable;
-        release_console_sem();
-        return rc;
-}
-int set_backlight_enable(int enable)
-{
-        if (!backlighter)
-                return -ENODEV;
-        backlight_req_enable = enable;
-        schedule_work(&backlight_work);
-        return 0;
-}
-
-EXPORT_SYMBOL(set_backlight_enable);
-
-int get_backlight_enable(void)
-{
-        if (!backlighter)
-                return -ENODEV;
-        return backlight_enabled;
-}
-EXPORT_SYMBOL(get_backlight_enable);
-
-static int __set_backlight_level(int level)
-{
-        int rc = 0;
-
-        if (!backlighter)
-                return -ENODEV;
-        if (level < BACKLIGHT_MIN)
-                level = BACKLIGHT_OFF;
-        if (level > BACKLIGHT_MAX)
-                level = BACKLIGHT_MAX;
-        acquire_console_sem();
-        if (backlight_enabled)
-                rc = backlighter->set_level(level, backlighter_data);
-        if (!rc)
-                backlight_level = level;
-        release_console_sem();
-        if (!rc && !backlight_autosave) {
-                level <<=1;
-                if (level & 0x10)
-                        level |= 0x01;
-                // -- todo: save to property "bklt"
-        }
-        return rc;
-}
-int set_backlight_level(int level)
-{
-        if (!backlighter)
-                return -ENODEV;
-        backlight_req_level = level;
-        schedule_work(&backlight_work);
-        return 0;
-}
-
-EXPORT_SYMBOL(set_backlight_level);
-
-int get_backlight_level(void)
-{
-        if (!backlighter)
-                return -ENODEV;
-        return backlight_level;
-}
-EXPORT_SYMBOL(get_backlight_level);
-
-static void backlight_callback(void *dummy)
-{
-        int level, enable;
-
-        do {
-                level = backlight_req_level;
-                enable = backlight_req_enable;
-                mb();
-
-                if (level >= 0)
-                        __set_backlight_level(level);
-                if (enable >= 0)
-                        __set_backlight_enable(enable);
-        } while(cmpxchg(&backlight_req_level, level, -1) != level ||
-                cmpxchg(&backlight_req_enable, enable, -1) != enable);
-}
diff --git a/arch/ppc/platforms/pmac_cache.S b/arch/ppc/platforms/pmac_cache.S
deleted file mode 100644
index fb977de6b704..000000000000
--- a/arch/ppc/platforms/pmac_cache.S
+++ /dev/null
@@ -1,359 +0,0 @@
-/*
- * This file contains low-level cache management functions
- * used for sleep and CPU speed changes on Apple machines.
- * (In fact the only thing that is Apple-specific is that we assume
- * that we can read from ROM at physical address 0xfff00000.)
- *
- *    Copyright (C) 2004 Paul Mackerras (paulus@samba.org) and
- *                       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.
- *
- */
-
-#include <linux/config.h>
-#include <asm/processor.h>
-#include <asm/ppc_asm.h>
-#include <asm/cputable.h>
-
-/*
- * Flush and disable all data caches (dL1, L2, L3). This is used
- * when going to sleep, when doing a PMU based cpufreq transition,
- * or when "offlining" a CPU on SMP machines. This code is over
- * paranoid, but I've had enough issues with various CPU revs and
- * bugs that I decided it was worth beeing over cautious
- */
-
-_GLOBAL(flush_disable_caches)
-#ifndef CONFIG_6xx
-        blr
-#else
-BEGIN_FTR_SECTION
-        b       flush_disable_745x
-END_FTR_SECTION_IFSET(CPU_FTR_SPEC7450)
-BEGIN_FTR_SECTION
-        b       flush_disable_75x
-END_FTR_SECTION_IFSET(CPU_FTR_L2CR)
-        b       __flush_disable_L1
-
-/* This is the code for G3 and 74[01]0 */
-flush_disable_75x:
-        mflr    r10
-
-        /* Turn off EE and DR in MSR */
-        mfmsr   r11
-        rlwinm  r0,r11,0,~MSR_EE
-        rlwinm  r0,r0,0,~MSR_DR
-        sync
-        mtmsr   r0
-        isync
-
-        /* Stop DST streams */
-BEGIN_FTR_SECTION
-        DSSALL
-        sync
-END_FTR_SECTION_IFSET(CPU_FTR_ALTIVEC)
-
-        /* Stop DPM */
-        mfspr   r8,SPRN_HID0            /* Save SPRN_HID0 in r8 */
-        rlwinm  r4,r8,0,12,10           /* Turn off HID0[DPM] */
-        sync
-        mtspr   SPRN_HID0,r4            /* Disable DPM */
-        sync
-
-        /* Disp-flush L1. We have a weird problem here that I never
-         * totally figured out. On 750FX, using the ROM for the flush
-         * results in a non-working flush. We use that workaround for
-         * now until I finally understand what's going on. --BenH
-         */
-
-        /* ROM base by default */
-        lis     r4,0xfff0
-        mfpvr   r3
-        srwi    r3,r3,16
-        cmplwi  cr0,r3,0x7000
-        bne+    1f
-        /* RAM base on 750FX */
-        li      r4,0
-1:      li      r4,0x4000
-        mtctr   r4
-1:      lwz     r0,0(r4)
-        addi    r4,r4,32
-        bdnz    1b
-        sync
-        isync
-
-        /* Disable / invalidate / enable L1 data */
-        mfspr   r3,SPRN_HID0
-        rlwinm  r3,r3,0,~(HID0_DCE | HID0_ICE)
-        mtspr   SPRN_HID0,r3
-        sync
-        isync
-        ori     r3,r3,(HID0_DCE|HID0_DCI|HID0_ICE|HID0_ICFI)
-        sync
-        isync
-        mtspr   SPRN_HID0,r3
-        xori    r3,r3,(HID0_DCI|HID0_ICFI)
-        mtspr   SPRN_HID0,r3
-        sync
-
-        /* Get the current enable bit of the L2CR into r4 */
-        mfspr   r5,SPRN_L2CR
-        /* Set to data-only (pre-745x bit) */
-        oris    r3,r5,L2CR_L2DO@h
-        b       2f
-        /* When disabling L2, code must be in L1 */
-        .balign 32
-1:      mtspr   SPRN_L2CR,r3
-3:      sync
-        isync
-        b       1f
-2:      b       3f
-3:      sync
-        isync
-        b       1b
-1:      /* disp-flush L2. The interesting thing here is that the L2 can be
-         * up to 2Mb ... so using the ROM, we'll end up wrapping back to memory
-         * but that is probbaly fine. We disp-flush over 4Mb to be safe
-         */
-        lis     r4,2
-        mtctr   r4
-        lis     r4,0xfff0
-1:      lwz     r0,0(r4)
-        addi    r4,r4,32
-        bdnz    1b
-        sync
-        isync
-        lis     r4,2
-        mtctr   r4
-        lis     r4,0xfff0
-1:      dcbf    0,r4
-        addi    r4,r4,32
-        bdnz    1b
-        sync
-        isync
-
-        /* now disable L2 */
-        rlwinm  r5,r5,0,~L2CR_L2E
-        b       2f
-        /* When disabling L2, code must be in L1 */
-        .balign 32
-1:      mtspr   SPRN_L2CR,r5
-3:      sync
-        isync
-        b       1f
-2:      b       3f
-3:      sync
-        isync
-        b       1b
-1:      sync
-        isync
-        /* Invalidate L2. This is pre-745x, we clear the L2I bit ourselves */
-        oris    r4,r5,L2CR_L2I@h
-        mtspr   SPRN_L2CR,r4
-        sync
-        isync
-
-        /* Wait for the invalidation to complete */
-1:      mfspr   r3,SPRN_L2CR
-        rlwinm. r0,r3,0,31,31
-        bne     1b
-
-        /* Clear L2I */
-        xoris   r4,r4,L2CR_L2I@h
-        sync
-        mtspr   SPRN_L2CR,r4
-        sync
-
-        /* now disable the L1 data cache */
-        mfspr   r0,SPRN_HID0
-        rlwinm  r0,r0,0,~(HID0_DCE|HID0_ICE)
-        mtspr   SPRN_HID0,r0
-        sync
-        isync
-
-        /* Restore HID0[DPM] to whatever it was before */
-        sync
-        mfspr   r0,SPRN_HID0
-        rlwimi  r0,r8,0,11,11           /* Turn back HID0[DPM] */
-        mtspr   SPRN_HID0,r0
-        sync
-
-        /* restore DR and EE */
-        sync
-        mtmsr   r11
-        isync
-
-        mtlr    r10
-        blr
-
-/* This code is for 745x processors */
-flush_disable_745x:
-        /* Turn off EE and DR in MSR */
-        mfmsr   r11
-        rlwinm  r0,r11,0,~MSR_EE
-        rlwinm  r0,r0,0,~MSR_DR
-        sync
-        mtmsr   r0
-        isync
-
-        /* Stop prefetch streams */
-        DSSALL
-        sync
-
-        /* Disable L2 prefetching */
-        mfspr   r0,SPRN_MSSCR0
-        rlwinm  r0,r0,0,0,29
-        mtspr   SPRN_MSSCR0,r0
-        sync
-        isync
-        lis     r4,0
-        dcbf    0,r4
-        dcbf    0,r4
-        dcbf    0,r4
-        dcbf    0,r4
-        dcbf    0,r4
-        dcbf    0,r4
-        dcbf    0,r4
-        dcbf    0,r4
-
-        /* Due to a bug with the HW flush on some CPU revs, we occasionally
-         * experience data corruption. I'm adding a displacement flush along
-         * with a dcbf loop over a few Mb to "help". The problem isn't totally
-         * fixed by this in theory, but at least, in practice, I couldn't reproduce
-         * it even with a big hammer...
-         */
-
-        lis     r4,0x0002
-        mtctr   r4
-        li      r4,0
-1:
-        lwz     r0,0(r4)
-        addi    r4,r4,32                /* Go to start of next cache line */
-        bdnz    1b
-        isync
-
-        /* Now, flush the first 4MB of memory */
-        lis     r4,0x0002
-        mtctr   r4
-        li      r4,0
-        sync
-1:
-        dcbf    0,r4
-        addi    r4,r4,32                /* Go to start of next cache line */
-        bdnz    1b
-
-        /* Flush and disable the L1 data cache */
-        mfspr   r6,SPRN_LDSTCR
-        lis     r3,0xfff0       /* read from ROM for displacement flush */
-        li      r4,0xfe         /* start with only way 0 unlocked */
-        li      r5,128          /* 128 lines in each way */
-1:      mtctr   r5
-        rlwimi  r6,r4,0,24,31
-        mtspr   SPRN_LDSTCR,r6
-        sync
-        isync
-2:      lwz     r0,0(r3)        /* touch each cache line */
-        addi    r3,r3,32
-        bdnz    2b
-        rlwinm  r4,r4,1,24,30   /* move on to the next way */
-        ori     r4,r4,1
-        cmpwi   r4,0xff         /* all done? */
-        bne     1b
-        /* now unlock the L1 data cache */
-        li      r4,0
-        rlwimi  r6,r4,0,24,31
-        sync
-        mtspr   SPRN_LDSTCR,r6
-        sync
-        isync
-
-        /* Flush the L2 cache using the hardware assist */
-        mfspr   r3,SPRN_L2CR
-        cmpwi   r3,0            /* check if it is enabled first */
-        bge     4f
-        oris    r0,r3,(L2CR_L2IO_745x|L2CR_L2DO_745x)@h
-        b       2f
-        /* When disabling/locking L2, code must be in L1 */
-        .balign 32
-1:      mtspr   SPRN_L2CR,r0    /* lock the L2 cache */
-3:      sync
-        isync
-        b       1f
-2:      b       3f
-3:      sync
-        isync
-        b       1b
-1:      sync
-        isync
-        ori     r0,r3,L2CR_L2HWF_745x
-        sync
-        mtspr   SPRN_L2CR,r0    /* set the hardware flush bit */
-3:      mfspr   r0,SPRN_L2CR    /* wait for it to go to 0 */
-        andi.   r0,r0,L2CR_L2HWF_745x
-        bne     3b
-        sync
-        rlwinm  r3,r3,0,~L2CR_L2E
-        b       2f
-        /* When disabling L2, code must be in L1 */
-        .balign 32
-1:      mtspr   SPRN_L2CR,r3    /* disable the L2 cache */
-3:      sync
-        isync
-        b       1f
-2:      b       3f
-3:      sync
-        isync
-        b       1b
-1:      sync
-        isync
-        oris    r4,r3,L2CR_L2I@h
-        mtspr   SPRN_L2CR,r4
-        sync
-        isync
-1:      mfspr   r4,SPRN_L2CR
-        andis.  r0,r4,L2CR_L2I@h
-        bne     1b
-        sync
-
-BEGIN_FTR_SECTION
-        /* Flush the L3 cache using the hardware assist */
-4:      mfspr   r3,SPRN_L3CR
-        cmpwi   r3,0            /* check if it is enabled */
-        bge     6f
-        oris    r0,r3,L3CR_L3IO@h
-        ori     r0,r0,L3CR_L3DO
-        sync
-        mtspr   SPRN_L3CR,r0    /* lock the L3 cache */
-        sync
-        isync
-        ori     r0,r0,L3CR_L3HWF
-        sync
-        mtspr   SPRN_L3CR,r0    /* set the hardware flush bit */
-5:      mfspr   r0,SPRN_L3CR    /* wait for it to go to zero */
-        andi.   r0,r0,L3CR_L3HWF
-        bne     5b
-        rlwinm  r3,r3,0,~L3CR_L3E
-        sync
-        mtspr   SPRN_L3CR,r3    /* disable the L3 cache */
-        sync
-        ori     r4,r3,L3CR_L3I
-        mtspr   SPRN_L3CR,r4
-1:      mfspr   r4,SPRN_L3CR
-        andi.   r0,r4,L3CR_L3I
-        bne     1b
-        sync
-END_FTR_SECTION_IFSET(CPU_FTR_L3CR)
-
-6:      mfspr   r0,SPRN_HID0    /* now disable the L1 data cache */
-        rlwinm  r0,r0,0,~HID0_DCE
-        mtspr   SPRN_HID0,r0
-        sync
-        isync
-        mtmsr   r11             /* restore DR and EE */
-        isync
-        blr
-#endif  /* CONFIG_6xx */
diff --git a/arch/ppc/platforms/pmac_cpufreq.c b/arch/ppc/platforms/pmac_cpufreq.c
deleted file mode 100644
index fba7e4d7c0bf..000000000000
--- a/arch/ppc/platforms/pmac_cpufreq.c
+++ /dev/null
@@ -1,735 +0,0 @@
-/*
- *  arch/ppc/platforms/pmac_cpufreq.c
- *
- *  Copyright (C) 2002 - 2005 Benjamin Herrenschmidt <benh@kernel.crashing.org>
- *  Copyright (C) 2004        John Steele Scott <toojays@toojays.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * TODO: Need a big cleanup here. Basically, we need to have different
- * cpufreq_driver structures for the different type of HW instead of the
- * current mess. We also need to better deal with the detection of the
- * type of machine.
- *
- */
-
-#include <linux/config.h>
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/errno.h>
-#include <linux/kernel.h>
-#include <linux/delay.h>
-#include <linux/sched.h>
-#include <linux/adb.h>
-#include <linux/pmu.h>
-#include <linux/slab.h>
-#include <linux/cpufreq.h>
-#include <linux/init.h>
-#include <linux/sysdev.h>
-#include <linux/i2c.h>
-#include <linux/hardirq.h>
-#include <asm/prom.h>
-#include <asm/machdep.h>
-#include <asm/irq.h>
-#include <asm/pmac_feature.h>
-#include <asm/mmu_context.h>
-#include <asm/sections.h>
-#include <asm/cputable.h>
-#include <asm/time.h>
-#include <asm/system.h>
-#include <asm/open_pic.h>
-#include <asm/keylargo.h>
-
-/* WARNING !!! This will cause calibrate_delay() to be called,
- * but this is an __init function ! So you MUST go edit
- * init/main.c to make it non-init before enabling DEBUG_FREQ
- */
-#undef DEBUG_FREQ
-
-/*
- * There is a problem with the core cpufreq code on SMP kernels,
- * it won't recalculate the Bogomips properly
- */
-#ifdef CONFIG_SMP
-#warning "WARNING, CPUFREQ not recommended on SMP kernels"
-#endif
-
-extern void low_choose_7447a_dfs(int dfs);
-extern void low_choose_750fx_pll(int pll);
-extern void low_sleep_handler(void);
-
-/*
- * Currently, PowerMac cpufreq supports only high & low frequencies
- * that are set by the firmware
- */
-static unsigned int low_freq;
-static unsigned int hi_freq;
-static unsigned int cur_freq;
-static unsigned int sleep_freq;
-
-/*
- * Different models uses different mecanisms to switch the frequency
- */
-static int (*set_speed_proc)(int low_speed);
-static unsigned int (*get_speed_proc)(void);
-
-/*
- * Some definitions used by the various speedprocs
- */
-static u32 voltage_gpio;
-static u32 frequency_gpio;
-static u32 slew_done_gpio;
-static int no_schedule;
-static int has_cpu_l2lve;
-static int is_pmu_based;
-
-/* There are only two frequency states for each processor. Values
- * are in kHz for the time being.
- */
-#define CPUFREQ_HIGH                  0
-#define CPUFREQ_LOW                   1
-
-static struct cpufreq_frequency_table pmac_cpu_freqs[] = {
-        {CPUFREQ_HIGH,          0},
-        {CPUFREQ_LOW,           0},
-        {0,                     CPUFREQ_TABLE_END},
-};
-
-static struct freq_attr* pmac_cpu_freqs_attr[] = {
-        &cpufreq_freq_attr_scaling_available_freqs,
-        NULL,
-};
-
-static inline void local_delay(unsigned long ms)
-{
-        if (no_schedule)
-                mdelay(ms);
-        else
-                msleep(ms);
-}
-
-static inline void wakeup_decrementer(void)
-{
-        set_dec(tb_ticks_per_jiffy);
-        /* No currently-supported powerbook has a 601,
-         * so use get_tbl, not native
-         */
-        last_jiffy_stamp(0) = tb_last_stamp = get_tbl();
-}
-
-#ifdef DEBUG_FREQ
-static inline void debug_calc_bogomips(void)
-{
-        /* This will cause a recalc of bogomips and display the
-         * result. We backup/restore the value to avoid affecting the
-         * core cpufreq framework's own calculation.
-         */
-        extern void calibrate_delay(void);
-
-        unsigned long save_lpj = loops_per_jiffy;
-        calibrate_delay();
-        loops_per_jiffy = save_lpj;
-}
-#endif /* DEBUG_FREQ */
-
-/* Switch CPU speed under 750FX CPU control
- */
-static int cpu_750fx_cpu_speed(int low_speed)
-{
-        u32 hid2;
-
-        if (low_speed == 0) {
-                /* ramping up, set voltage first */
-                pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, voltage_gpio, 0x05);
-                /* Make sure we sleep for at least 1ms */
-                local_delay(10);
-
-                /* tweak L2 for high voltage */
-                if (has_cpu_l2lve) {
-                        hid2 = mfspr(SPRN_HID2);
-                        hid2 &= ~0x2000;
-                        mtspr(SPRN_HID2, hid2);
-                }
-        }
-#ifdef CONFIG_6xx
-        low_choose_750fx_pll(low_speed);
-#endif
-        if (low_speed == 1) {
-                /* tweak L2 for low voltage */
-                if (has_cpu_l2lve) {
-                        hid2 = mfspr(SPRN_HID2);
-                        hid2 |= 0x2000;
-                        mtspr(SPRN_HID2, hid2);
-                }
-
-                /* ramping down, set voltage last */
-                pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, voltage_gpio, 0x04);
-                local_delay(10);
-        }
-
-        return 0;
-}
-
-static unsigned int cpu_750fx_get_cpu_speed(void)
-{
-        if (mfspr(SPRN_HID1) & HID1_PS)
-                return low_freq;
-        else
-                return hi_freq;
-}
-
-/* Switch CPU speed using DFS */
-static int dfs_set_cpu_speed(int low_speed)
-{
-        if (low_speed == 0) {
-                /* ramping up, set voltage first */
-                pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, voltage_gpio, 0x05);
-                /* Make sure we sleep for at least 1ms */
-                local_delay(1);
-        }
-
-        /* set frequency */
-#ifdef CONFIG_6xx
-        low_choose_7447a_dfs(low_speed);
-#endif
-        udelay(100);
-
-        if (low_speed == 1) {
-                /* ramping down, set voltage last */
-                pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, voltage_gpio, 0x04);
-                local_delay(1);
-        }
-
-        return 0;
-}
-
-static unsigned int dfs_get_cpu_speed(void)
-{
-        if (mfspr(SPRN_HID1) & HID1_DFS)
-                return low_freq;
-        else
-                return hi_freq;
-}
-
-
-/* Switch CPU speed using slewing GPIOs
- */
-static int gpios_set_cpu_speed(int low_speed)
-{
-        int gpio, timeout = 0;
-
-        /* If ramping up, set voltage first */
-        if (low_speed == 0) {
-                pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, voltage_gpio, 0x05);
-                /* Delay is way too big but it's ok, we schedule */
-                local_delay(10);
-        }
-
-        /* Set frequency */
-        gpio =  pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, frequency_gpio, 0);
-        if (low_speed == ((gpio & 0x01) == 0))
-                goto skip;
-
-        pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, frequency_gpio,
-                          low_speed ? 0x04 : 0x05);
-        udelay(200);
-        do {
-                if (++timeout > 100)
-                        break;
-                local_delay(1);
-                gpio = pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, slew_done_gpio, 0);
-        } while((gpio & 0x02) == 0);
- skip:
-        /* If ramping down, set voltage last */
-        if (low_speed == 1) {
-                pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, voltage_gpio, 0x04);
-                /* Delay is way too big but it's ok, we schedule */
-                local_delay(10);
-        }
-
-#ifdef DEBUG_FREQ
-        debug_calc_bogomips();
-#endif
-
-        return 0;
-}
-
-/* Switch CPU speed under PMU control
- */
-static int pmu_set_cpu_speed(int low_speed)
-{
-        struct adb_request req;
-        unsigned long save_l2cr;
-        unsigned long save_l3cr;
-        unsigned int pic_prio;
-        unsigned long flags;
-
-        preempt_disable();
-
-#ifdef DEBUG_FREQ
-        printk(KERN_DEBUG "HID1, before: %x\n", mfspr(SPRN_HID1));
-#endif
-        pmu_suspend();
-
-        /* Disable all interrupt sources on openpic */
-        pic_prio = openpic_get_priority();
-        openpic_set_priority(0xf);
-
-        /* Make sure the decrementer won't interrupt us */
-        asm volatile("mtdec %0" : : "r" (0x7fffffff));
-        /* Make sure any pending DEC interrupt occuring while we did
-         * the above didn't re-enable the DEC */
-        mb();
-        asm volatile("mtdec %0" : : "r" (0x7fffffff));
-
-        /* We can now disable MSR_EE */
-        local_irq_save(flags);
-
-        /* Giveup the FPU & vec */
-        enable_kernel_fp();
-
-#ifdef CONFIG_ALTIVEC
-        if (cpu_has_feature(CPU_FTR_ALTIVEC))
-                enable_kernel_altivec();
-#endif /* CONFIG_ALTIVEC */
-
-        /* Save & disable L2 and L3 caches */
-        save_l3cr = _get_L3CR();        /* (returns -1 if not available) */
-        save_l2cr = _get_L2CR();        /* (returns -1 if not available) */
-
-        /* Send the new speed command. My assumption is that this command
-         * will cause PLL_CFG[0..3] to be changed next time CPU goes to sleep
-         */
-        pmu_request(&req, NULL, 6, PMU_CPU_SPEED, 'W', 'O', 'O', 'F', low_speed);
-        while (!req.complete)
-                pmu_poll();
-
-        /* Prepare the northbridge for the speed transition */
-        pmac_call_feature(PMAC_FTR_SLEEP_STATE,NULL,1,1);
-
-        /* Call low level code to backup CPU state and recover from
-         * hardware reset
-         */
-        low_sleep_handler();
-
-        /* Restore the northbridge */
-        pmac_call_feature(PMAC_FTR_SLEEP_STATE,NULL,1,0);
-
-        /* Restore L2 cache */
-        if (save_l2cr != 0xffffffff && (save_l2cr & L2CR_L2E) != 0)
-                _set_L2CR(save_l2cr);
-        /* Restore L3 cache */
-        if (save_l3cr != 0xffffffff && (save_l3cr & L3CR_L3E) != 0)
-                _set_L3CR(save_l3cr);
-
-        /* Restore userland MMU context */
-        set_context(current->active_mm->context, current->active_mm->pgd);
-
-#ifdef DEBUG_FREQ
-        printk(KERN_DEBUG "HID1, after: %x\n", mfspr(SPRN_HID1));
-#endif
-
-        /* Restore low level PMU operations */
-        pmu_unlock();
-
-        /* Restore decrementer */
-        wakeup_decrementer();
-
-        /* Restore interrupts */
-        openpic_set_priority(pic_prio);
-
-        /* Let interrupts flow again ... */
-        local_irq_restore(flags);
-
-#ifdef DEBUG_FREQ
-        debug_calc_bogomips();
-#endif
-
-        pmu_resume();
-
-        preempt_enable();
-
-        return 0;
-}
-
-static int do_set_cpu_speed(int speed_mode, int notify)
-{
-        struct cpufreq_freqs freqs;
-        unsigned long l3cr;
-        static unsigned long prev_l3cr;
-
-        freqs.old = cur_freq;
-        freqs.new = (speed_mode == CPUFREQ_HIGH) ? hi_freq : low_freq;
-        freqs.cpu = smp_processor_id();
-
-        if (freqs.old == freqs.new)
-                return 0;
-
-        if (notify)
-                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-        if (speed_mode == CPUFREQ_LOW &&
-            cpu_has_feature(CPU_FTR_L3CR)) {
-                l3cr = _get_L3CR();
-                if (l3cr & L3CR_L3E) {
-                        prev_l3cr = l3cr;
-                        _set_L3CR(0);
-                }
-        }
-        set_speed_proc(speed_mode == CPUFREQ_LOW);
-        if (speed_mode == CPUFREQ_HIGH &&
-            cpu_has_feature(CPU_FTR_L3CR)) {
-                l3cr = _get_L3CR();
-                if ((prev_l3cr & L3CR_L3E) && l3cr != prev_l3cr)
-                        _set_L3CR(prev_l3cr);
-        }
-        if (notify)
-                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-        cur_freq = (speed_mode == CPUFREQ_HIGH) ? hi_freq : low_freq;
-
-        return 0;
-}
-
-static unsigned int pmac_cpufreq_get_speed(unsigned int cpu)
-{
-        return cur_freq;
-}
-
-static int pmac_cpufreq_verify(struct cpufreq_policy *policy)
-{
-        return cpufreq_frequency_table_verify(policy, pmac_cpu_freqs);
-}
-
-static int pmac_cpufreq_target( struct cpufreq_policy *policy,
-                                        unsigned int target_freq,
-                                        unsigned int relation)
-{
-        unsigned int    newstate = 0;
-
-        if (cpufreq_frequency_table_target(policy, pmac_cpu_freqs,
-                        target_freq, relation, &newstate))
-                return -EINVAL;
-
-        return do_set_cpu_speed(newstate, 1);
-}
-
-unsigned int pmac_get_one_cpufreq(int i)
-{
-        /* Supports only one CPU for now */
-        return (i == 0) ? cur_freq : 0;
-}
-
-static int pmac_cpufreq_cpu_init(struct cpufreq_policy *policy)
-{
-        if (policy->cpu != 0)
-                return -ENODEV;
-
-        policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
-        policy->cpuinfo.transition_latency      = CPUFREQ_ETERNAL;
-        policy->cur = cur_freq;
-
-        cpufreq_frequency_table_get_attr(pmac_cpu_freqs, policy->cpu);
-        return cpufreq_frequency_table_cpuinfo(policy, pmac_cpu_freqs);
-}
-
-static u32 read_gpio(struct device_node *np)
-{
-        u32 *reg = (u32 *)get_property(np, "reg", NULL);
-        u32 offset;
-
-        if (reg == NULL)
-                return 0;
-        /* That works for all keylargos but shall be fixed properly
-         * some day... The problem is that it seems we can't rely
-         * on the "reg" property of the GPIO nodes, they are either
-         * relative to the base of KeyLargo or to the base of the
-         * GPIO space, and the device-tree doesn't help.
-         */
-        offset = *reg;
-        if (offset < KEYLARGO_GPIO_LEVELS0)
-                offset += KEYLARGO_GPIO_LEVELS0;
-        return offset;
-}
-
-static int pmac_cpufreq_suspend(struct cpufreq_policy *policy, pm_message_t pmsg)
-{
-        /* Ok, this could be made a bit smarter, but let's be robust for now. We
-         * always force a speed change to high speed before sleep, to make sure
-         * we have appropriate voltage and/or bus speed for the wakeup process,
-         * and to make sure our loops_per_jiffies are "good enough", that is will
-         * not cause too short delays if we sleep in low speed and wake in high
-         * speed..
-         */
-        no_schedule = 1;
-        sleep_freq = cur_freq;
-        if (cur_freq == low_freq && !is_pmu_based)
-                do_set_cpu_speed(CPUFREQ_HIGH, 0);
-        return 0;
-}
-
-static int pmac_cpufreq_resume(struct cpufreq_policy *policy)
-{
-        /* If we resume, first check if we have a get() function */
-        if (get_speed_proc)
-                cur_freq = get_speed_proc();
-        else
-                cur_freq = 0;
-
-        /* We don't, hrm... we don't really know our speed here, best
-         * is that we force a switch to whatever it was, which is
-         * probably high speed due to our suspend() routine
-         */
-        do_set_cpu_speed(sleep_freq == low_freq ?
-                         CPUFREQ_LOW : CPUFREQ_HIGH, 0);
-
-        no_schedule = 0;
-        return 0;
-}
-
-static struct cpufreq_driver pmac_cpufreq_driver = {
-        .verify         = pmac_cpufreq_verify,
-        .target         = pmac_cpufreq_target,
-        .get            = pmac_cpufreq_get_speed,
-        .init           = pmac_cpufreq_cpu_init,
-        .suspend        = pmac_cpufreq_suspend,
-        .resume         = pmac_cpufreq_resume,
-        .flags          = CPUFREQ_PM_NO_WARN,
-        .attr           = pmac_cpu_freqs_attr,
-        .name           = "powermac",
-        .owner          = THIS_MODULE,
-};
-
-
-static int pmac_cpufreq_init_MacRISC3(struct device_node *cpunode)
-{
-        struct device_node *volt_gpio_np = of_find_node_by_name(NULL,
-                                                                "voltage-gpio");
-        struct device_node *freq_gpio_np = of_find_node_by_name(NULL,
-                                                                "frequency-gpio");
-        struct device_node *slew_done_gpio_np = of_find_node_by_name(NULL,
-                                                                     "slewing-done");
-        u32 *value;
-
-        /*
-         * Check to see if it's GPIO driven or PMU only
-         *
-         * The way we extract the GPIO address is slightly hackish, but it
-         * works well enough for now. We need to abstract the whole GPIO
-         * stuff sooner or later anyway
-         */
-
-        if (volt_gpio_np)
-                voltage_gpio = read_gpio(volt_gpio_np);
-        if (freq_gpio_np)
-                frequency_gpio = read_gpio(freq_gpio_np);
-        if (slew_done_gpio_np)
-                slew_done_gpio = read_gpio(slew_done_gpio_np);
-
-        /* If we use the frequency GPIOs, calculate the min/max speeds based
-         * on the bus frequencies
-         */
-        if (frequency_gpio && slew_done_gpio) {
-                int lenp, rc;
-                u32 *freqs, *ratio;
-
-                freqs = (u32 *)get_property(cpunode, "bus-frequencies", &lenp);
-                lenp /= sizeof(u32);
-                if (freqs == NULL || lenp != 2) {
-                        printk(KERN_ERR "cpufreq: bus-frequencies incorrect or missing\n");
-                        return 1;
-                }
-                ratio = (u32 *)get_property(cpunode, "processor-to-bus-ratio*2", NULL);
-                if (ratio == NULL) {
-                        printk(KERN_ERR "cpufreq: processor-to-bus-ratio*2 missing\n");
-                        return 1;
-                }
-
-                /* Get the min/max bus frequencies */
-                low_freq = min(freqs[0], freqs[1]);
-                hi_freq = max(freqs[0], freqs[1]);
-
-                /* Grrrr.. It _seems_ that the device-tree is lying on the low bus
-                 * frequency, it claims it to be around 84Mhz on some models while
-                 * it appears to be approx. 101Mhz on all. Let's hack around here...
-                 * fortunately, we don't need to be too precise
-                 */
-                if (low_freq < 98000000)
-                        low_freq = 101000000;
-                        
-                /* Convert those to CPU core clocks */
-                low_freq = (low_freq * (*ratio)) / 2000;
-                hi_freq = (hi_freq * (*ratio)) / 2000;
-
-                /* Now we get the frequencies, we read the GPIO to see what is out current
-                 * speed
-                 */
-                rc = pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, frequency_gpio, 0);
-                cur_freq = (rc & 0x01) ? hi_freq : low_freq;
-
-                set_speed_proc = gpios_set_cpu_speed;
-                return 1;
-        }
-
-        /* If we use the PMU, look for the min & max frequencies in the
-         * device-tree
-         */
-        value = (u32 *)get_property(cpunode, "min-clock-frequency", NULL);
-        if (!value)
-                return 1;
-        low_freq = (*value) / 1000;
-        /* The PowerBook G4 12" (PowerBook6,1) has an error in the device-tree
-         * here */
-        if (low_freq < 100000)
-                low_freq *= 10;
-
-        value = (u32 *)get_property(cpunode, "max-clock-frequency", NULL);
-        if (!value)
-                return 1;
-        hi_freq = (*value) / 1000;
-        set_speed_proc = pmu_set_cpu_speed;
-        is_pmu_based = 1;
-
-        return 0;
-}
-
-static int pmac_cpufreq_init_7447A(struct device_node *cpunode)
-{
-        struct device_node *volt_gpio_np;
-
-        if (get_property(cpunode, "dynamic-power-step", NULL) == NULL)
-                return 1;
-
-        volt_gpio_np = of_find_node_by_name(NULL, "cpu-vcore-select");
-        if (volt_gpio_np)
-                voltage_gpio = read_gpio(volt_gpio_np);
-        if (!voltage_gpio){
-                printk(KERN_ERR "cpufreq: missing cpu-vcore-select gpio\n");
-                return 1;
-        }
-
-        /* OF only reports the high frequency */
-        hi_freq = cur_freq;
-        low_freq = cur_freq/2;
-
-        /* Read actual frequency from CPU */
-        cur_freq = dfs_get_cpu_speed();
-        set_speed_proc = dfs_set_cpu_speed;
-        get_speed_proc = dfs_get_cpu_speed;
-
-        return 0;
-}
-
-static int pmac_cpufreq_init_750FX(struct device_node *cpunode)
-{
-        struct device_node *volt_gpio_np;
-        u32 pvr, *value;
-
-        if (get_property(cpunode, "dynamic-power-step", NULL) == NULL)
-                return 1;
-
-        hi_freq = cur_freq;
-        value = (u32 *)get_property(cpunode, "reduced-clock-frequency", NULL);
-        if (!value)
-                return 1;
-        low_freq = (*value) / 1000;
-
-        volt_gpio_np = of_find_node_by_name(NULL, "cpu-vcore-select");
-        if (volt_gpio_np)
-                voltage_gpio = read_gpio(volt_gpio_np);
-
-        pvr = mfspr(SPRN_PVR);
-        has_cpu_l2lve = !((pvr & 0xf00) == 0x100);
-
-        set_speed_proc = cpu_750fx_cpu_speed;
-        get_speed_proc = cpu_750fx_get_cpu_speed;
-        cur_freq = cpu_750fx_get_cpu_speed();
-
-        return 0;
-}
-
-/* Currently, we support the following machines:
- *
- *  - Titanium PowerBook 1Ghz (PMU based, 667Mhz & 1Ghz)
- *  - Titanium PowerBook 800 (PMU based, 667Mhz & 800Mhz)
- *  - Titanium PowerBook 400 (PMU based, 300Mhz & 400Mhz)
- *  - Titanium PowerBook 500 (PMU based, 300Mhz & 500Mhz)
- *  - iBook2 500/600 (PMU based, 400Mhz & 500/600Mhz)
- *  - iBook2 700 (CPU based, 400Mhz & 700Mhz, support low voltage)
- *  - Recent MacRISC3 laptops
- *  - All new machines with 7447A CPUs
- */
-static int __init pmac_cpufreq_setup(void)
-{
-        struct device_node      *cpunode;
-        u32                     *value;
-
-        if (strstr(cmd_line, "nocpufreq"))
-                return 0;
-
-        /* Assume only one CPU */
-        cpunode = find_type_devices("cpu");
-        if (!cpunode)
-                goto out;
-
-        /* Get current cpu clock freq */
-        value = (u32 *)get_property(cpunode, "clock-frequency", NULL);
-        if (!value)
-                goto out;
-        cur_freq = (*value) / 1000;
-
-        /*  Check for 7447A based MacRISC3 */
-        if (machine_is_compatible("MacRISC3") &&
-            get_property(cpunode, "dynamic-power-step", NULL) &&
-            PVR_VER(mfspr(SPRN_PVR)) == 0x8003) {
-                pmac_cpufreq_init_7447A(cpunode);
-        /* Check for other MacRISC3 machines */
-        } else if (machine_is_compatible("PowerBook3,4") ||
-                   machine_is_compatible("PowerBook3,5") ||
-                   machine_is_compatible("MacRISC3")) {
-                pmac_cpufreq_init_MacRISC3(cpunode);
-        /* Else check for iBook2 500/600 */
-        } else if (machine_is_compatible("PowerBook4,1")) {
-                hi_freq = cur_freq;
-                low_freq = 400000;
-                set_speed_proc = pmu_set_cpu_speed;
-                is_pmu_based = 1;
-        }
-        /* Else check for TiPb 550 */
-        else if (machine_is_compatible("PowerBook3,3") && cur_freq == 550000) {
-                hi_freq = cur_freq;
-                low_freq = 500000;
-                set_speed_proc = pmu_set_cpu_speed;
-                is_pmu_based = 1;
-        }
-        /* Else check for TiPb 400 & 500 */
-        else if (machine_is_compatible("PowerBook3,2")) {
-                /* We only know about the 400 MHz and the 500Mhz model
-                 * they both have 300 MHz as low frequency
-                 */
-                if (cur_freq < 350000 || cur_freq > 550000)
-                        goto out;
-                hi_freq = cur_freq;
-                low_freq = 300000;
-                set_speed_proc = pmu_set_cpu_speed;
-                is_pmu_based = 1;
-        }
-        /* Else check for 750FX */
-        else if (PVR_VER(mfspr(SPRN_PVR)) == 0x7000)
-                pmac_cpufreq_init_750FX(cpunode);
-out:
-        if (set_speed_proc == NULL)
-                return -ENODEV;
-
-        pmac_cpu_freqs[CPUFREQ_LOW].frequency = low_freq;
-        pmac_cpu_freqs[CPUFREQ_HIGH].frequency = hi_freq;
-
-        printk(KERN_INFO "Registering PowerMac CPU frequency driver\n");
-        printk(KERN_INFO "Low: %d Mhz, High: %d Mhz, Boot: %d Mhz\n",
-               low_freq/1000, hi_freq/1000, cur_freq/1000);
-
-        return cpufreq_register_driver(&pmac_cpufreq_driver);
-}
-
-module_init(pmac_cpufreq_setup);
-
diff --git a/arch/ppc/platforms/pmac_feature.c b/arch/ppc/platforms/pmac_feature.c
deleted file mode 100644
index 6b7b3a150631..000000000000
--- a/arch/ppc/platforms/pmac_feature.c
+++ /dev/null
@@ -1,3023 +0,0 @@
-/*
- *  arch/ppc/platforms/pmac_feature.c
- *
- *  Copyright (C) 1996-2001 Paul Mackerras (paulus@cs.anu.edu.au)
- *                          Ben. 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.
- *
- *  TODO:
- *
- *   - Replace mdelay with some schedule loop if possible
- *   - Shorten some obfuscated delays on some routines (like modem
- *     power)
- *   - Refcount some clocks (see darwin)
- *   - Split split split...
- *
- */
-#include <linux/config.h>
-#include <linux/types.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/kernel.h>
-#include <linux/sched.h>
-#include <linux/spinlock.h>
-#include <linux/adb.h>
-#include <linux/pmu.h>
-#include <linux/ioport.h>
-#include <linux/pci.h>
-#include <asm/sections.h>
-#include <asm/errno.h>
-#include <asm/ohare.h>
-#include <asm/heathrow.h>
-#include <asm/keylargo.h>
-#include <asm/uninorth.h>
-#include <asm/io.h>
-#include <asm/prom.h>
-#include <asm/machdep.h>
-#include <asm/pmac_feature.h>
-#include <asm/dbdma.h>
-#include <asm/pci-bridge.h>
-#include <asm/pmac_low_i2c.h>
-
-#undef DEBUG_FEATURE
-
-#ifdef DEBUG_FEATURE
-#define DBG(fmt,...) printk(KERN_DEBUG fmt)
-#else
-#define DBG(fmt,...)
-#endif
-
-#ifdef CONFIG_6xx
-extern int powersave_lowspeed;
-#endif
-
-extern int powersave_nap;
-extern struct device_node *k2_skiplist[2];
-
-
-/*
- * We use a single global lock to protect accesses. Each driver has
- * to take care of its own locking
- */
-static DEFINE_SPINLOCK(feature_lock);
-
-#define LOCK(flags)     spin_lock_irqsave(&feature_lock, flags);
-#define UNLOCK(flags)   spin_unlock_irqrestore(&feature_lock, flags);
-
-
-/*
- * Instance of some macio stuffs
- */
-struct macio_chip macio_chips[MAX_MACIO_CHIPS];
-
-struct macio_chip* macio_find(struct device_node* child, int type)
-{
-        while(child) {
-                int     i;
-
-                for (i=0; i < MAX_MACIO_CHIPS && macio_chips[i].of_node; i++)
-                        if (child == macio_chips[i].of_node &&
-                            (!type || macio_chips[i].type == type))
-                                return &macio_chips[i];
-                child = child->parent;
-        }
-        return NULL;
-}
-EXPORT_SYMBOL_GPL(macio_find);
-
-static const char* macio_names[] =
-{
-        "Unknown",
-        "Grand Central",
-        "OHare",
-        "OHareII",
-        "Heathrow",
-        "Gatwick",
-        "Paddington",
-        "Keylargo",
-        "Pangea",
-        "Intrepid",
-        "K2"
-};
-
-
-
-/*
- * Uninorth reg. access. Note that Uni-N regs are big endian
- */
-
-#define UN_REG(r)       (uninorth_base + ((r) >> 2))
-#define UN_IN(r)        (in_be32(UN_REG(r)))
-#define UN_OUT(r,v)     (out_be32(UN_REG(r), (v)))
-#define UN_BIS(r,v)     (UN_OUT((r), UN_IN(r) | (v)))
-#define UN_BIC(r,v)     (UN_OUT((r), UN_IN(r) & ~(v)))
-
-static struct device_node* uninorth_node;
-static u32 __iomem * uninorth_base;
-static u32 uninorth_rev;
-static int uninorth_u3;
-static void __iomem *u3_ht;
-
-/*
- * For each motherboard family, we have a table of functions pointers
- * that handle the various features.
- */
-
-typedef long (*feature_call)(struct device_node* node, long param, long value);
-
-struct feature_table_entry {
-        unsigned int    selector;
-        feature_call    function;
-};
-
-struct pmac_mb_def
-{
-        const char*                     model_string;
-        const char*                     model_name;
-        int                             model_id;
-        struct feature_table_entry*     features;
-        unsigned long                   board_flags;
-};
-static struct pmac_mb_def pmac_mb;
-
-/*
- * Here are the chip specific feature functions
- */
-
-static inline int
-simple_feature_tweak(struct device_node* node, int type, int reg, u32 mask, int value)
-{
-        struct macio_chip*      macio;
-        unsigned long           flags;
-
-        macio = macio_find(node, type);
-        if (!macio)
-                return -ENODEV;
-        LOCK(flags);
-        if (value)
-                MACIO_BIS(reg, mask);
-        else
-                MACIO_BIC(reg, mask);
-        (void)MACIO_IN32(reg);
-        UNLOCK(flags);
-
-        return 0;
-}
-
-#ifndef CONFIG_POWER4
-
-static long
-ohare_htw_scc_enable(struct device_node* node, long param, long value)
-{
-        struct macio_chip*      macio;
-        unsigned long           chan_mask;
-        unsigned long           fcr;
-        unsigned long           flags;
-        int                     htw, trans;
-        unsigned long           rmask;
-
-        macio = macio_find(node, 0);
-        if (!macio)
-                return -ENODEV;
-        if (!strcmp(node->name, "ch-a"))
-                chan_mask = MACIO_FLAG_SCCA_ON;
-        else if (!strcmp(node->name, "ch-b"))
-                chan_mask = MACIO_FLAG_SCCB_ON;
-        else
-                return -ENODEV;
-
-        htw = (macio->type == macio_heathrow || macio->type == macio_paddington
-                || macio->type == macio_gatwick);
-        /* On these machines, the HRW_SCC_TRANS_EN_N bit mustn't be touched */
-        trans = (pmac_mb.model_id != PMAC_TYPE_YOSEMITE &&
-                 pmac_mb.model_id != PMAC_TYPE_YIKES);
-        if (value) {
-#ifdef CONFIG_ADB_PMU
-                if ((param & 0xfff) == PMAC_SCC_IRDA)
-                        pmu_enable_irled(1);
-#endif /* CONFIG_ADB_PMU */
-                LOCK(flags);
-                fcr = MACIO_IN32(OHARE_FCR);
-                /* Check if scc cell need enabling */
-                if (!(fcr & OH_SCC_ENABLE)) {
-                        fcr |= OH_SCC_ENABLE;
-                        if (htw) {
-                                /* Side effect: this will also power up the
-                                 * modem, but it's too messy to figure out on which
-                                 * ports this controls the tranceiver and on which
-                                 * it controls the modem
-                                 */
-                                if (trans)
-                                        fcr &= ~HRW_SCC_TRANS_EN_N;
-                                MACIO_OUT32(OHARE_FCR, fcr);
-                                fcr |= (rmask = HRW_RESET_SCC);
-                                MACIO_OUT32(OHARE_FCR, fcr);
-                        } else {
-                                fcr |= (rmask = OH_SCC_RESET);
-                                MACIO_OUT32(OHARE_FCR, fcr);
-                        }
-                        UNLOCK(flags);
-                        (void)MACIO_IN32(OHARE_FCR);
-                        mdelay(15);
-                        LOCK(flags);
-                        fcr &= ~rmask;
-                        MACIO_OUT32(OHARE_FCR, fcr);
-                }
-                if (chan_mask & MACIO_FLAG_SCCA_ON)
-                        fcr |= OH_SCCA_IO;
-                if (chan_mask & MACIO_FLAG_SCCB_ON)
-                        fcr |= OH_SCCB_IO;
-                MACIO_OUT32(OHARE_FCR, fcr);
-                macio->flags |= chan_mask;
-                UNLOCK(flags);
-                if (param & PMAC_SCC_FLAG_XMON)
-                        macio->flags |= MACIO_FLAG_SCC_LOCKED;
-        } else {
-                if (macio->flags & MACIO_FLAG_SCC_LOCKED)
-                        return -EPERM;
-                LOCK(flags);
-                fcr = MACIO_IN32(OHARE_FCR);
-                if (chan_mask & MACIO_FLAG_SCCA_ON)
-                        fcr &= ~OH_SCCA_IO;
-                if (chan_mask & MACIO_FLAG_SCCB_ON)
-                        fcr &= ~OH_SCCB_IO;
-                MACIO_OUT32(OHARE_FCR, fcr);
-                if ((fcr & (OH_SCCA_IO | OH_SCCB_IO)) == 0) {
-                        fcr &= ~OH_SCC_ENABLE;
-                        if (htw && trans)
-                                fcr |= HRW_SCC_TRANS_EN_N;
-                        MACIO_OUT32(OHARE_FCR, fcr);
-                }
-                macio->flags &= ~(chan_mask);
-                UNLOCK(flags);
-                mdelay(10);
-#ifdef CONFIG_ADB_PMU
-                if ((param & 0xfff) == PMAC_SCC_IRDA)
-                        pmu_enable_irled(0);
-#endif /* CONFIG_ADB_PMU */
-        }
-        return 0;
-}
-
-static long
-ohare_floppy_enable(struct device_node* node, long param, long value)
-{
-        return simple_feature_tweak(node, macio_ohare,
-                OHARE_FCR, OH_FLOPPY_ENABLE, value);
-}
-
-static long
-ohare_mesh_enable(struct device_node* node, long param, long value)
-{
-        return simple_feature_tweak(node, macio_ohare,
-                OHARE_FCR, OH_MESH_ENABLE, value);
-}
-
-static long
-ohare_ide_enable(struct device_node* node, long param, long value)
-{
-        switch(param) {
-            case 0:
-                /* For some reason, setting the bit in set_initial_features()
-                 * doesn't stick. I'm still investigating... --BenH.
-                 */
-                if (value)
-                        simple_feature_tweak(node, macio_ohare,
-                                OHARE_FCR, OH_IOBUS_ENABLE, 1);
-                return simple_feature_tweak(node, macio_ohare,
-                        OHARE_FCR, OH_IDE0_ENABLE, value);
-            case 1:
-                return simple_feature_tweak(node, macio_ohare,
-                        OHARE_FCR, OH_BAY_IDE_ENABLE, value);
-            default:
-                return -ENODEV;
-        }
-}
-
-static long
-ohare_ide_reset(struct device_node* node, long param, long value)
-{
-        switch(param) {
-            case 0:
-                return simple_feature_tweak(node, macio_ohare,
-                        OHARE_FCR, OH_IDE0_RESET_N, !value);
-            case 1:
-                return simple_feature_tweak(node, macio_ohare,
-                        OHARE_FCR, OH_IDE1_RESET_N, !value);
-            default:
-                return -ENODEV;
-        }
-}
-
-static long
-ohare_sleep_state(struct device_node* node, long param, long value)
-{
-        struct macio_chip*      macio = &macio_chips[0];
-
-        if ((pmac_mb.board_flags & PMAC_MB_CAN_SLEEP) == 0)
-                return -EPERM;
-        if (value == 1) {
-                MACIO_BIC(OHARE_FCR, OH_IOBUS_ENABLE);
-        } else if (value == 0) {
-                MACIO_BIS(OHARE_FCR, OH_IOBUS_ENABLE);
-        }
-
-        return 0;
-}
-
-static long
-heathrow_modem_enable(struct device_node* node, long param, long value)
-{
-        struct macio_chip*      macio;
-        u8                      gpio;
-        unsigned long           flags;
-
-        macio = macio_find(node, macio_unknown);
-        if (!macio)
-                return -ENODEV;
-        gpio = MACIO_IN8(HRW_GPIO_MODEM_RESET) & ~1;
-        if (!value) {
-                LOCK(flags);
-                MACIO_OUT8(HRW_GPIO_MODEM_RESET, gpio);
-                UNLOCK(flags);
-                (void)MACIO_IN8(HRW_GPIO_MODEM_RESET);
-                mdelay(250);
-        }
-        if (pmac_mb.model_id != PMAC_TYPE_YOSEMITE &&
-            pmac_mb.model_id != PMAC_TYPE_YIKES) {
-                LOCK(flags);
-                if (value)
-                        MACIO_BIC(HEATHROW_FCR, HRW_SCC_TRANS_EN_N);
-                else
-                        MACIO_BIS(HEATHROW_FCR, HRW_SCC_TRANS_EN_N);
-                UNLOCK(flags);
-                (void)MACIO_IN32(HEATHROW_FCR);
-                mdelay(250);
-        }
-        if (value) {
-                LOCK(flags);
-                MACIO_OUT8(HRW_GPIO_MODEM_RESET, gpio | 1);
-                (void)MACIO_IN8(HRW_GPIO_MODEM_RESET);
-                UNLOCK(flags); mdelay(250); LOCK(flags);
-                MACIO_OUT8(HRW_GPIO_MODEM_RESET, gpio);
-                (void)MACIO_IN8(HRW_GPIO_MODEM_RESET);
-                UNLOCK(flags); mdelay(250); LOCK(flags);
-                MACIO_OUT8(HRW_GPIO_MODEM_RESET, gpio | 1);
-                (void)MACIO_IN8(HRW_GPIO_MODEM_RESET);
-                UNLOCK(flags); mdelay(250);
-        }
-        return 0;
-}
-
-static long
-heathrow_floppy_enable(struct device_node* node, long param, long value)
-{
-        return simple_feature_tweak(node, macio_unknown,
-                HEATHROW_FCR,
-                HRW_SWIM_ENABLE|HRW_BAY_FLOPPY_ENABLE,
-                value);
-}
-
-static long
-heathrow_mesh_enable(struct device_node* node, long param, long value)
-{
-        struct macio_chip*      macio;
-        unsigned long           flags;
-
-        macio = macio_find(node, macio_unknown);
-        if (!macio)
-                return -ENODEV;
-        LOCK(flags);
-        /* Set clear mesh cell enable */
-        if (value)
-                MACIO_BIS(HEATHROW_FCR, HRW_MESH_ENABLE);
-        else
-                MACIO_BIC(HEATHROW_FCR, HRW_MESH_ENABLE);
-        (void)MACIO_IN32(HEATHROW_FCR);
-        udelay(10);
-        /* Set/Clear termination power */
-        if (value)
-                MACIO_BIC(HEATHROW_MBCR, 0x04000000);
-        else
-                MACIO_BIS(HEATHROW_MBCR, 0x04000000);
-        (void)MACIO_IN32(HEATHROW_MBCR);
-        udelay(10);
-        UNLOCK(flags);
-
-        return 0;
-}
-
-static long
-heathrow_ide_enable(struct device_node* node, long param, long value)
-{
-        switch(param) {
-            case 0:
-                return simple_feature_tweak(node, macio_unknown,
-                        HEATHROW_FCR, HRW_IDE0_ENABLE, value);
-            case 1:
-                return simple_feature_tweak(node, macio_unknown,
-                        HEATHROW_FCR, HRW_BAY_IDE_ENABLE, value);
-            default:
-                return -ENODEV;
-        }
-}
-
-static long
-heathrow_ide_reset(struct device_node* node, long param, long value)
-{
-        switch(param) {
-            case 0:
-                return simple_feature_tweak(node, macio_unknown,
-                        HEATHROW_FCR, HRW_IDE0_RESET_N, !value);
-            case 1:
-                return simple_feature_tweak(node, macio_unknown,
-                        HEATHROW_FCR, HRW_IDE1_RESET_N, !value);
-            default:
-                return -ENODEV;
-        }
-}
-
-static long
-heathrow_bmac_enable(struct device_node* node, long param, long value)
-{
-        struct macio_chip*      macio;
-        unsigned long           flags;
-
-        macio = macio_find(node, 0);
-        if (!macio)
-                return -ENODEV;
-        if (value) {
-                LOCK(flags);
-                MACIO_BIS(HEATHROW_FCR, HRW_BMAC_IO_ENABLE);
-                MACIO_BIS(HEATHROW_FCR, HRW_BMAC_RESET);
-                UNLOCK(flags);
-                (void)MACIO_IN32(HEATHROW_FCR);
-                mdelay(10);
-                LOCK(flags);
-                MACIO_BIC(HEATHROW_FCR, HRW_BMAC_RESET);
-                UNLOCK(flags);
-                (void)MACIO_IN32(HEATHROW_FCR);
-                mdelay(10);
-        } else {
-                LOCK(flags);
-                MACIO_BIC(HEATHROW_FCR, HRW_BMAC_IO_ENABLE);
-                UNLOCK(flags);
-        }
-        return 0;
-}
-
-static long
-heathrow_sound_enable(struct device_node* node, long param, long value)
-{
-        struct macio_chip*      macio;
-        unsigned long           flags;
-
-        /* B&W G3 and Yikes don't support that properly (the
-         * sound appear to never come back after beeing shut down).
-         */
-        if (pmac_mb.model_id == PMAC_TYPE_YOSEMITE ||
-            pmac_mb.model_id == PMAC_TYPE_YIKES)
-                return 0;
-
-        macio = macio_find(node, 0);
-        if (!macio)
-                return -ENODEV;
-        if (value) {
-                LOCK(flags);
-                MACIO_BIS(HEATHROW_FCR, HRW_SOUND_CLK_ENABLE);
-                MACIO_BIC(HEATHROW_FCR, HRW_SOUND_POWER_N);
-                UNLOCK(flags);
-                (void)MACIO_IN32(HEATHROW_FCR);
-        } else {
-                LOCK(flags);
-                MACIO_BIS(HEATHROW_FCR, HRW_SOUND_POWER_N);
-                MACIO_BIC(HEATHROW_FCR, HRW_SOUND_CLK_ENABLE);
-                UNLOCK(flags);
-        }
-        return 0;
-}
-
-static u32 save_fcr[6];
-static u32 save_mbcr;
-static u32 save_gpio_levels[2];
-static u8 save_gpio_extint[KEYLARGO_GPIO_EXTINT_CNT];
-static u8 save_gpio_normal[KEYLARGO_GPIO_CNT];
-static u32 save_unin_clock_ctl;
-static struct dbdma_regs save_dbdma[13];
-static struct dbdma_regs save_alt_dbdma[13];
-
-static void
-dbdma_save(struct macio_chip* macio, struct dbdma_regs* save)
-{
-        int i;
-
-        /* Save state & config of DBDMA channels */
-        for (i=0; i<13; i++) {
-                volatile struct dbdma_regs __iomem * chan = (void __iomem *)
-                        (macio->base + ((0x8000+i*0x100)>>2));
-                save[i].cmdptr_hi = in_le32(&chan->cmdptr_hi);
-                save[i].cmdptr = in_le32(&chan->cmdptr);
-                save[i].intr_sel = in_le32(&chan->intr_sel);
-                save[i].br_sel = in_le32(&chan->br_sel);
-                save[i].wait_sel = in_le32(&chan->wait_sel);
-        }
-}
-
-static void
-dbdma_restore(struct macio_chip* macio, struct dbdma_regs* save)
-{
-        int i;
-
-        /* Save state & config of DBDMA channels */
-        for (i=0; i<13; i++) {
-                volatile struct dbdma_regs __iomem * chan = (void __iomem *)
-                        (macio->base + ((0x8000+i*0x100)>>2));
-                out_le32(&chan->control, (ACTIVE|DEAD|WAKE|FLUSH|PAUSE|RUN)<<16);
-                while (in_le32(&chan->status) & ACTIVE)
-                        mb();
-                out_le32(&chan->cmdptr_hi, save[i].cmdptr_hi);
-                out_le32(&chan->cmdptr, save[i].cmdptr);
-                out_le32(&chan->intr_sel, save[i].intr_sel);
-                out_le32(&chan->br_sel, save[i].br_sel);
-                out_le32(&chan->wait_sel, save[i].wait_sel);
-        }
-}
-
-static void
-heathrow_sleep(struct macio_chip* macio, int secondary)
-{
-        if (secondary) {
-                dbdma_save(macio, save_alt_dbdma);
-                save_fcr[2] = MACIO_IN32(0x38);
-                save_fcr[3] = MACIO_IN32(0x3c);
-        } else {
-                dbdma_save(macio, save_dbdma);
-                save_fcr[0] = MACIO_IN32(0x38);
-                save_fcr[1] = MACIO_IN32(0x3c);
-                save_mbcr = MACIO_IN32(0x34);
-                /* Make sure sound is shut down */
-                MACIO_BIS(HEATHROW_FCR, HRW_SOUND_POWER_N);
-                MACIO_BIC(HEATHROW_FCR, HRW_SOUND_CLK_ENABLE);
-                /* This seems to be necessary as well or the fan
-                 * keeps coming up and battery drains fast */
-                MACIO_BIC(HEATHROW_FCR, HRW_IOBUS_ENABLE);
-                MACIO_BIC(HEATHROW_FCR, HRW_IDE0_RESET_N);
-                /* Make sure eth is down even if module or sleep
-                 * won't work properly */
-                MACIO_BIC(HEATHROW_FCR, HRW_BMAC_IO_ENABLE | HRW_BMAC_RESET);
-        }
-        /* Make sure modem is shut down */
-        MACIO_OUT8(HRW_GPIO_MODEM_RESET,
-                MACIO_IN8(HRW_GPIO_MODEM_RESET) & ~1);
-        MACIO_BIS(HEATHROW_FCR, HRW_SCC_TRANS_EN_N);
-        MACIO_BIC(HEATHROW_FCR, OH_SCCA_IO|OH_SCCB_IO|HRW_SCC_ENABLE);
-
-        /* Let things settle */
-        (void)MACIO_IN32(HEATHROW_FCR);
-}
-
-static void
-heathrow_wakeup(struct macio_chip* macio, int secondary)
-{
-        if (secondary) {
-                MACIO_OUT32(0x38, save_fcr[2]);
-                (void)MACIO_IN32(0x38);
-                mdelay(1);
-                MACIO_OUT32(0x3c, save_fcr[3]);
-                (void)MACIO_IN32(0x38);
-                mdelay(10);
-                dbdma_restore(macio, save_alt_dbdma);
-        } else {
-                MACIO_OUT32(0x38, save_fcr[0] | HRW_IOBUS_ENABLE);
-                (void)MACIO_IN32(0x38);
-                mdelay(1);
-                MACIO_OUT32(0x3c, save_fcr[1]);
-                (void)MACIO_IN32(0x38);
-                mdelay(1);
-                MACIO_OUT32(0x34, save_mbcr);
-                (void)MACIO_IN32(0x38);
-                mdelay(10);
-                dbdma_restore(macio, save_dbdma);
-        }
-}
-
-static long
-heathrow_sleep_state(struct device_node* node, long param, long value)
-{
-        if ((pmac_mb.board_flags & PMAC_MB_CAN_SLEEP) == 0)
-                return -EPERM;
-        if (value == 1) {
-                if (macio_chips[1].type == macio_gatwick)
-                        heathrow_sleep(&macio_chips[0], 1);
-                heathrow_sleep(&macio_chips[0], 0);
-        } else if (value == 0) {
-                heathrow_wakeup(&macio_chips[0], 0);
-                if (macio_chips[1].type == macio_gatwick)
-                        heathrow_wakeup(&macio_chips[0], 1);
-        }
-        return 0;
-}
-
-static long
-core99_scc_enable(struct device_node* node, long param, long value)
-{
-        struct macio_chip*      macio;
-        unsigned long           flags;
-        unsigned long           chan_mask;
-        u32                     fcr;
-
-        macio = macio_find(node, 0);
-        if (!macio)
-                return -ENODEV;
-        if (!strcmp(node->name, "ch-a"))
-                chan_mask = MACIO_FLAG_SCCA_ON;
-        else if (!strcmp(node->name, "ch-b"))
-                chan_mask = MACIO_FLAG_SCCB_ON;
-        else
-                return -ENODEV;
-
-        if (value) {
-                int need_reset_scc = 0;
-                int need_reset_irda = 0;
-
-                LOCK(flags);
-                fcr = MACIO_IN32(KEYLARGO_FCR0);
-                /* Check if scc cell need enabling */
-                if (!(fcr & KL0_SCC_CELL_ENABLE)) {
-                        fcr |= KL0_SCC_CELL_ENABLE;
-                        need_reset_scc = 1;
-                }
-                if (chan_mask & MACIO_FLAG_SCCA_ON) {
-                        fcr |= KL0_SCCA_ENABLE;
-                        /* Don't enable line drivers for I2S modem */
-                        if ((param & 0xfff) == PMAC_SCC_I2S1)
-                                fcr &= ~KL0_SCC_A_INTF_ENABLE;
-                        else
-                                fcr |= KL0_SCC_A_INTF_ENABLE;
-                }
-                if (chan_mask & MACIO_FLAG_SCCB_ON) {
-                        fcr |= KL0_SCCB_ENABLE;
-                        /* Perform irda specific inits */
-                        if ((param & 0xfff) == PMAC_SCC_IRDA) {
-                                fcr &= ~KL0_SCC_B_INTF_ENABLE;
-                                fcr |= KL0_IRDA_ENABLE;
-                                fcr |= KL0_IRDA_CLK32_ENABLE | KL0_IRDA_CLK19_ENABLE;
-                                fcr |= KL0_IRDA_SOURCE1_SEL;
-                                fcr &= ~(KL0_IRDA_FAST_CONNECT|KL0_IRDA_DEFAULT1|KL0_IRDA_DEFAULT0);
-                                fcr &= ~(KL0_IRDA_SOURCE2_SEL|KL0_IRDA_HIGH_BAND);
-                                need_reset_irda = 1;
-                        } else
-                                fcr |= KL0_SCC_B_INTF_ENABLE;
-                }
-                MACIO_OUT32(KEYLARGO_FCR0, fcr);
-                macio->flags |= chan_mask;
-                if (need_reset_scc)  {
-                        MACIO_BIS(KEYLARGO_FCR0, KL0_SCC_RESET);
-                        (void)MACIO_IN32(KEYLARGO_FCR0);
-                        UNLOCK(flags);
-                        mdelay(15);
-                        LOCK(flags);
-                        MACIO_BIC(KEYLARGO_FCR0, KL0_SCC_RESET);
-                }
-                if (need_reset_irda)  {
-                        MACIO_BIS(KEYLARGO_FCR0, KL0_IRDA_RESET);
-                        (void)MACIO_IN32(KEYLARGO_FCR0);
-                        UNLOCK(flags);
-                        mdelay(15);
-                        LOCK(flags);
-                        MACIO_BIC(KEYLARGO_FCR0, KL0_IRDA_RESET);
-                }
-                UNLOCK(flags);
-                if (param & PMAC_SCC_FLAG_XMON)
-                        macio->flags |= MACIO_FLAG_SCC_LOCKED;
-        } else {
-                if (macio->flags & MACIO_FLAG_SCC_LOCKED)
-                        return -EPERM;
-                LOCK(flags);
-                fcr = MACIO_IN32(KEYLARGO_FCR0);
-                if (chan_mask & MACIO_FLAG_SCCA_ON)
-                        fcr &= ~KL0_SCCA_ENABLE;
-                if (chan_mask & MACIO_FLAG_SCCB_ON) {
-                        fcr &= ~KL0_SCCB_ENABLE;
-                        /* Perform irda specific clears */
-                        if ((param & 0xfff) == PMAC_SCC_IRDA) {
-                                fcr &= ~KL0_IRDA_ENABLE;
-                                fcr &= ~(KL0_IRDA_CLK32_ENABLE | KL0_IRDA_CLK19_ENABLE);
-                                fcr &= ~(KL0_IRDA_FAST_CONNECT|KL0_IRDA_DEFAULT1|KL0_IRDA_DEFAULT0);
-                                fcr &= ~(KL0_IRDA_SOURCE1_SEL|KL0_IRDA_SOURCE2_SEL|KL0_IRDA_HIGH_BAND);
-                        }
-                }
-                MACIO_OUT32(KEYLARGO_FCR0, fcr);
-                if ((fcr & (KL0_SCCA_ENABLE | KL0_SCCB_ENABLE)) == 0) {
-                        fcr &= ~KL0_SCC_CELL_ENABLE;
-                        MACIO_OUT32(KEYLARGO_FCR0, fcr);
-                }
-                macio->flags &= ~(chan_mask);
-                UNLOCK(flags);
-                mdelay(10);
-        }
-        return 0;
-}
-
-static long
-core99_modem_enable(struct device_node* node, long param, long value)
-{
-        struct macio_chip*      macio;
-        u8                      gpio;
-        unsigned long           flags;
-
-        /* Hack for internal USB modem */
-        if (node == NULL) {
-                if (macio_chips[0].type != macio_keylargo)
-                        return -ENODEV;
-                node = macio_chips[0].of_node;
-        }
-        macio = macio_find(node, 0);
-        if (!macio)
-                return -ENODEV;
-        gpio = MACIO_IN8(KL_GPIO_MODEM_RESET);
-        gpio |= KEYLARGO_GPIO_OUTPUT_ENABLE;
-        gpio &= ~KEYLARGO_GPIO_OUTOUT_DATA;
-
-        if (!value) {
-                LOCK(flags);
-                MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio);
-                UNLOCK(flags);
-                (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
-                mdelay(250);
-        }
-        LOCK(flags);
-        if (value) {
-                MACIO_BIC(KEYLARGO_FCR2, KL2_ALT_DATA_OUT);
-                UNLOCK(flags);
-                (void)MACIO_IN32(KEYLARGO_FCR2);
-                mdelay(250);
-        } else {
-                MACIO_BIS(KEYLARGO_FCR2, KL2_ALT_DATA_OUT);
-                UNLOCK(flags);
-        }
-        if (value) {
-                LOCK(flags);
-                MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio | KEYLARGO_GPIO_OUTOUT_DATA);
-                (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
-                UNLOCK(flags); mdelay(250); LOCK(flags);
-                MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio);
-                (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
-                UNLOCK(flags); mdelay(250); LOCK(flags);
-                MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio | KEYLARGO_GPIO_OUTOUT_DATA);
-                (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
-                UNLOCK(flags); mdelay(250);
-        }
-        return 0;
-}
-
-static long
-pangea_modem_enable(struct device_node* node, long param, long value)
-{
-        struct macio_chip*      macio;
-        u8                      gpio;
-        unsigned long           flags;
-
-        /* Hack for internal USB modem */
-        if (node == NULL) {
-                if (macio_chips[0].type != macio_pangea &&
-                    macio_chips[0].type != macio_intrepid)
-                        return -ENODEV;
-                node = macio_chips[0].of_node;
-        }
-        macio = macio_find(node, 0);
-        if (!macio)
-                return -ENODEV;
-        gpio = MACIO_IN8(KL_GPIO_MODEM_RESET);
-        gpio |= KEYLARGO_GPIO_OUTPUT_ENABLE;
-        gpio &= ~KEYLARGO_GPIO_OUTOUT_DATA;
-
-        if (!value) {
-                LOCK(flags);
-                MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio);
-                UNLOCK(flags);
-                (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
-                mdelay(250);
-        }
-        LOCK(flags);
-        if (value) {
-                MACIO_OUT8(KL_GPIO_MODEM_POWER,
-                        KEYLARGO_GPIO_OUTPUT_ENABLE);
-                UNLOCK(flags);
-                (void)MACIO_IN32(KEYLARGO_FCR2);
-                mdelay(250);
-        } else {
-                MACIO_OUT8(KL_GPIO_MODEM_POWER,
-                        KEYLARGO_GPIO_OUTPUT_ENABLE | KEYLARGO_GPIO_OUTOUT_DATA);
-                UNLOCK(flags);
-        }
-        if (value) {
-                LOCK(flags);
-                MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio | KEYLARGO_GPIO_OUTOUT_DATA);
-                (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
-                UNLOCK(flags); mdelay(250); LOCK(flags);
-                MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio);
-                (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
-                UNLOCK(flags); mdelay(250); LOCK(flags);
-                MACIO_OUT8(KL_GPIO_MODEM_RESET, gpio | KEYLARGO_GPIO_OUTOUT_DATA);
-                (void)MACIO_IN8(KL_GPIO_MODEM_RESET);
-                UNLOCK(flags); mdelay(250);
-        }
-        return 0;
-}
-
-static long
-core99_ata100_enable(struct device_node* node, long value)
-{
-        unsigned long flags;
-        struct pci_dev *pdev = NULL;
-        u8 pbus, pid;
-
-        if (uninorth_rev < 0x24)
-                return -ENODEV;
-
-        LOCK(flags);
-        if (value)
-                UN_BIS(UNI_N_CLOCK_CNTL, UNI_N_CLOCK_CNTL_ATA100);
-        else
-                UN_BIC(UNI_N_CLOCK_CNTL, UNI_N_CLOCK_CNTL_ATA100);
-        (void)UN_IN(UNI_N_CLOCK_CNTL);
-        UNLOCK(flags);
-        udelay(20);
-
-        if (value) {
-                if (pci_device_from_OF_node(node, &pbus, &pid) == 0)
-                        pdev = pci_find_slot(pbus, pid);
-                if (pdev == NULL)
-                        return 0;
-                pci_enable_device(pdev);
-                pci_set_master(pdev);
-        }
-        return 0;
-}
-
-static long
-core99_ide_enable(struct device_node* node, long param, long value)
-{
-        /* Bus ID 0 to 2 are KeyLargo based IDE, busID 3 is U2
-         * based ata-100
-         */
-        switch(param) {
-            case 0:
-                return simple_feature_tweak(node, macio_unknown,
-                        KEYLARGO_FCR1, KL1_EIDE0_ENABLE, value);
-            case 1:
-                return simple_feature_tweak(node, macio_unknown,
-                        KEYLARGO_FCR1, KL1_EIDE1_ENABLE, value);
-            case 2:
-                return simple_feature_tweak(node, macio_unknown,
-                        KEYLARGO_FCR1, KL1_UIDE_ENABLE, value);
-            case 3:
-                return core99_ata100_enable(node, value);
-            default:
-                return -ENODEV;
-        }
-}
-
-static long
-core99_ide_reset(struct device_node* node, long param, long value)
-{
-        switch(param) {
-            case 0:
-                return simple_feature_tweak(node, macio_unknown,
-                        KEYLARGO_FCR1, KL1_EIDE0_RESET_N, !value);
-            case 1:
-                return simple_feature_tweak(node, macio_unknown,
-                        KEYLARGO_FCR1, KL1_EIDE1_RESET_N, !value);
-            case 2:
-                return simple_feature_tweak(node, macio_unknown,
-                        KEYLARGO_FCR1, KL1_UIDE_RESET_N, !value);
-            default:
-                return -ENODEV;
-        }
-}
-
-static long
-core99_gmac_enable(struct device_node* node, long param, long value)
-{
-        unsigned long flags;
-
-        LOCK(flags);
-        if (value)
-                UN_BIS(UNI_N_CLOCK_CNTL, UNI_N_CLOCK_CNTL_GMAC);
-        else
-                UN_BIC(UNI_N_CLOCK_CNTL, UNI_N_CLOCK_CNTL_GMAC);
-        (void)UN_IN(UNI_N_CLOCK_CNTL);
-        UNLOCK(flags);
-        udelay(20);
-
-        return 0;
-}
-
-static long
-core99_gmac_phy_reset(struct device_node* node, long param, long value)
-{
-        unsigned long flags;
-        struct macio_chip* macio;
-
-        macio = &macio_chips[0];
-        if (macio->type != macio_keylargo && macio->type != macio_pangea &&
-            macio->type != macio_intrepid)
-                return -ENODEV;
-
-        LOCK(flags);
-        MACIO_OUT8(KL_GPIO_ETH_PHY_RESET, KEYLARGO_GPIO_OUTPUT_ENABLE);
-        (void)MACIO_IN8(KL_GPIO_ETH_PHY_RESET);
-        UNLOCK(flags);
-        mdelay(10);
-        LOCK(flags);
-        MACIO_OUT8(KL_GPIO_ETH_PHY_RESET, /*KEYLARGO_GPIO_OUTPUT_ENABLE | */
-                KEYLARGO_GPIO_OUTOUT_DATA);
-        UNLOCK(flags);
-        mdelay(10);
-
-        return 0;
-}
-
-static long
-core99_sound_chip_enable(struct device_node* node, long param, long value)
-{
-        struct macio_chip*      macio;
-        unsigned long           flags;
-
-        macio = macio_find(node, 0);
-        if (!macio)
-                return -ENODEV;
-
-        /* Do a better probe code, screamer G4 desktops &
-         * iMacs can do that too, add a recalibrate  in
-         * the driver as well
-         */
-        if (pmac_mb.model_id == PMAC_TYPE_PISMO ||
-            pmac_mb.model_id == PMAC_TYPE_TITANIUM) {
-                LOCK(flags);
-                if (value)
-                        MACIO_OUT8(KL_GPIO_SOUND_POWER,
-                                KEYLARGO_GPIO_OUTPUT_ENABLE |
-                                KEYLARGO_GPIO_OUTOUT_DATA);
-                else
-                        MACIO_OUT8(KL_GPIO_SOUND_POWER,
-                                KEYLARGO_GPIO_OUTPUT_ENABLE);
-                (void)MACIO_IN8(KL_GPIO_SOUND_POWER);
-                UNLOCK(flags);
-        }
-        return 0;
-}
-
-static long
-core99_airport_enable(struct device_node* node, long param, long value)
-{
-        struct macio_chip*      macio;
-        unsigned long           flags;
-        int                     state;
-
-        macio = macio_find(node, 0);
-        if (!macio)
-                return -ENODEV;
-
-        /* Hint: we allow passing of macio itself for the sake of the
-         * sleep code
-         */
-        if (node != macio->of_node &&
-            (!node->parent || node->parent != macio->of_node))
-                return -ENODEV;
-        state = (macio->flags & MACIO_FLAG_AIRPORT_ON) != 0;
-        if (value == state)
-                return 0;
-        if (value) {
-                /* This code is a reproduction of OF enable-cardslot
-                 * and init-wireless methods, slightly hacked until
-                 * I got it working.
-                 */
-                LOCK(flags);
-                MACIO_OUT8(KEYLARGO_GPIO_0+0xf, 5);
-                (void)MACIO_IN8(KEYLARGO_GPIO_0+0xf);
-                UNLOCK(flags);
-                mdelay(10);
-                LOCK(flags);
-                MACIO_OUT8(KEYLARGO_GPIO_0+0xf, 4);
-                (void)MACIO_IN8(KEYLARGO_GPIO_0+0xf);
-                UNLOCK(flags);
-
-                mdelay(10);
-
-                LOCK(flags);
-                MACIO_BIC(KEYLARGO_FCR2, KL2_CARDSEL_16);
-                (void)MACIO_IN32(KEYLARGO_FCR2);
-                udelay(10);
-                MACIO_OUT8(KEYLARGO_GPIO_EXTINT_0+0xb, 0);
-                (void)MACIO_IN8(KEYLARGO_GPIO_EXTINT_0+0xb);
-                udelay(10);
-                MACIO_OUT8(KEYLARGO_GPIO_EXTINT_0+0xa, 0x28);
-                (void)MACIO_IN8(KEYLARGO_GPIO_EXTINT_0+0xa);
-                udelay(10);
-                MACIO_OUT8(KEYLARGO_GPIO_EXTINT_0+0xd, 0x28);
-                (void)MACIO_IN8(KEYLARGO_GPIO_EXTINT_0+0xd);
-                udelay(10);
-                MACIO_OUT8(KEYLARGO_GPIO_0+0xd, 0x28);
-                (void)MACIO_IN8(KEYLARGO_GPIO_0+0xd);
-                udelay(10);
-                MACIO_OUT8(KEYLARGO_GPIO_0+0xe, 0x28);
-                (void)MACIO_IN8(KEYLARGO_GPIO_0+0xe);
-                UNLOCK(flags);
-                udelay(10);
-                MACIO_OUT32(0x1c000, 0);
-                mdelay(1);
-                MACIO_OUT8(0x1a3e0, 0x41);
-                (void)MACIO_IN8(0x1a3e0);
-                udelay(10);
-                LOCK(flags);
-                MACIO_BIS(KEYLARGO_FCR2, KL2_CARDSEL_16);
-                (void)MACIO_IN32(KEYLARGO_FCR2);
-                UNLOCK(flags);
-                mdelay(100);
-
-                macio->flags |= MACIO_FLAG_AIRPORT_ON;
-        } else {
-                LOCK(flags);
-                MACIO_BIC(KEYLARGO_FCR2, KL2_CARDSEL_16);
-                (void)MACIO_IN32(KEYLARGO_FCR2);
-                MACIO_OUT8(KL_GPIO_AIRPORT_0, 0);
-                MACIO_OUT8(KL_GPIO_AIRPORT_1, 0);
-                MACIO_OUT8(KL_GPIO_AIRPORT_2, 0);
-                MACIO_OUT8(KL_GPIO_AIRPORT_3, 0);
-                MACIO_OUT8(KL_GPIO_AIRPORT_4, 0);
-                (void)MACIO_IN8(KL_GPIO_AIRPORT_4);
-                UNLOCK(flags);
-
-                macio->flags &= ~MACIO_FLAG_AIRPORT_ON;
-        }
-        return 0;
-}
-
-#ifdef CONFIG_SMP
-static long
-core99_reset_cpu(struct device_node* node, long param, long value)
-{
-        unsigned int reset_io = 0;
-        unsigned long flags;
-        struct macio_chip* macio;
-        struct device_node* np;
-        const int dflt_reset_lines[] = {        KL_GPIO_RESET_CPU0,
-                                                KL_GPIO_RESET_CPU1,
-                                                KL_GPIO_RESET_CPU2,
-                                                KL_GPIO_RESET_CPU3 };
-
-        macio = &macio_chips[0];
-        if (macio->type != macio_keylargo)
-                return -ENODEV;
-
-        np = find_path_device("/cpus");
-        if (np == NULL)
-                return -ENODEV;
-        for (np = np->child; np != NULL; np = np->sibling) {
-                u32* num = (u32 *)get_property(np, "reg", NULL);
-                u32* rst = (u32 *)get_property(np, "soft-reset", NULL);
-                if (num == NULL || rst == NULL)
-                        continue;
-                if (param == *num) {
-                        reset_io = *rst;
-                        break;
-                }
-        }
-        if (np == NULL || reset_io == 0)
-                reset_io = dflt_reset_lines[param];
-
-        LOCK(flags);
-        MACIO_OUT8(reset_io, KEYLARGO_GPIO_OUTPUT_ENABLE);
-        (void)MACIO_IN8(reset_io);
-        udelay(1);
-        MACIO_OUT8(reset_io, 0);
-        (void)MACIO_IN8(reset_io);
-        UNLOCK(flags);
-
-        return 0;
-}
-#endif /* CONFIG_SMP */
-
-static long
-core99_usb_enable(struct device_node* node, long param, long value)
-{
-        struct macio_chip* macio;
-        unsigned long flags;
-        char* prop;
-        int number;
-        u32 reg;
-
-        macio = &macio_chips[0];
-        if (macio->type != macio_keylargo && macio->type != macio_pangea &&
-            macio->type != macio_intrepid)
-                return -ENODEV;
-
-        prop = (char *)get_property(node, "AAPL,clock-id", NULL);
-        if (!prop)
-                return -ENODEV;
-        if (strncmp(prop, "usb0u048", 8) == 0)
-                number = 0;
-        else if (strncmp(prop, "usb1u148", 8) == 0)
-                number = 2;
-        else if (strncmp(prop, "usb2u248", 8) == 0)
-                number = 4;
-        else
-                return -ENODEV;
-
-        /* Sorry for the brute-force locking, but this is only used during
-         * sleep and the timing seem to be critical
-         */
-        LOCK(flags);
-        if (value) {
-                /* Turn ON */
-                if (number == 0) {
-                        MACIO_BIC(KEYLARGO_FCR0, (KL0_USB0_PAD_SUSPEND0 | KL0_USB0_PAD_SUSPEND1));
-                        (void)MACIO_IN32(KEYLARGO_FCR0);
-                        UNLOCK(flags);
-                        mdelay(1);
-                        LOCK(flags);
-                        MACIO_BIS(KEYLARGO_FCR0, KL0_USB0_CELL_ENABLE);
-                } else if (number == 2) {
-                        MACIO_BIC(KEYLARGO_FCR0, (KL0_USB1_PAD_SUSPEND0 | KL0_USB1_PAD_SUSPEND1));
-                        UNLOCK(flags);
-                        (void)MACIO_IN32(KEYLARGO_FCR0);
-                        mdelay(1);
-                        LOCK(flags);
-                        MACIO_BIS(KEYLARGO_FCR0, KL0_USB1_CELL_ENABLE);
-                } else if (number == 4) {
-                        MACIO_BIC(KEYLARGO_FCR1, (KL1_USB2_PAD_SUSPEND0 | KL1_USB2_PAD_SUSPEND1));
-                        UNLOCK(flags);
-                        (void)MACIO_IN32(KEYLARGO_FCR1);
-                        mdelay(1);
-                        LOCK(flags);
-                        MACIO_BIS(KEYLARGO_FCR1, KL1_USB2_CELL_ENABLE);
-                }
-                if (number < 4) {
-                        reg = MACIO_IN32(KEYLARGO_FCR4);
-                        reg &=  ~(KL4_PORT_WAKEUP_ENABLE(number) | KL4_PORT_RESUME_WAKE_EN(number) |
-                                KL4_PORT_CONNECT_WAKE_EN(number) | KL4_PORT_DISCONNECT_WAKE_EN(number));
-                        reg &=  ~(KL4_PORT_WAKEUP_ENABLE(number+1) | KL4_PORT_RESUME_WAKE_EN(number+1) |
-                                KL4_PORT_CONNECT_WAKE_EN(number+1) | KL4_PORT_DISCONNECT_WAKE_EN(number+1));
-                        MACIO_OUT32(KEYLARGO_FCR4, reg);
-                        (void)MACIO_IN32(KEYLARGO_FCR4);
-                        udelay(10);
-                } else {
-                        reg = MACIO_IN32(KEYLARGO_FCR3);
-                        reg &=  ~(KL3_IT_PORT_WAKEUP_ENABLE(0) | KL3_IT_PORT_RESUME_WAKE_EN(0) |
-                                KL3_IT_PORT_CONNECT_WAKE_EN(0) | KL3_IT_PORT_DISCONNECT_WAKE_EN(0));
-                        reg &=  ~(KL3_IT_PORT_WAKEUP_ENABLE(1) | KL3_IT_PORT_RESUME_WAKE_EN(1) |
-                                KL3_IT_PORT_CONNECT_WAKE_EN(1) | KL3_IT_PORT_DISCONNECT_WAKE_EN(1));
-                        MACIO_OUT32(KEYLARGO_FCR3, reg);
-                        (void)MACIO_IN32(KEYLARGO_FCR3);
-                        udelay(10);
-                }
-                if (macio->type == macio_intrepid) {
-                        /* wait for clock stopped bits to clear */
-                        u32 test0 = 0, test1 = 0;
-                        u32 status0, status1;
-                        int timeout = 1000;
-
-                        UNLOCK(flags);
-                        switch (number) {
-                        case 0:
-                                test0 = UNI_N_CLOCK_STOPPED_USB0;
-                                test1 = UNI_N_CLOCK_STOPPED_USB0PCI;
-                                break;
-                        case 2:
-                                test0 = UNI_N_CLOCK_STOPPED_USB1;
-                                test1 = UNI_N_CLOCK_STOPPED_USB1PCI;
-                                break;
-                        case 4:
-                                test0 = UNI_N_CLOCK_STOPPED_USB2;
-                                test1 = UNI_N_CLOCK_STOPPED_USB2PCI;
-                                break;
-                        }
-                        do {
-                                if (--timeout <= 0) {
-                                        printk(KERN_ERR "core99_usb_enable: "
-                                               "Timeout waiting for clocks\n");
-                                        break;
-                                }
-                                mdelay(1);
-                                status0 = UN_IN(UNI_N_CLOCK_STOP_STATUS0);
-                                status1 = UN_IN(UNI_N_CLOCK_STOP_STATUS1);
-                        } while ((status0 & test0) | (status1 & test1));
-                        LOCK(flags);
-                }
-        } else {
-                /* Turn OFF */
-                if (number < 4) {
-                        reg = MACIO_IN32(KEYLARGO_FCR4);
-                        reg |=  KL4_PORT_WAKEUP_ENABLE(number) | KL4_PORT_RESUME_WAKE_EN(number) |
-                                KL4_PORT_CONNECT_WAKE_EN(number) | KL4_PORT_DISCONNECT_WAKE_EN(number);
-                        reg |=  KL4_PORT_WAKEUP_ENABLE(number+1) | KL4_PORT_RESUME_WAKE_EN(number+1) |
-                                KL4_PORT_CONNECT_WAKE_EN(number+1) | KL4_PORT_DISCONNECT_WAKE_EN(number+1);
-                        MACIO_OUT32(KEYLARGO_FCR4, reg);
-                        (void)MACIO_IN32(KEYLARGO_FCR4);
-                        udelay(1);
-                } else {
-                        reg = MACIO_IN32(KEYLARGO_FCR3);
-                        reg |=  KL3_IT_PORT_WAKEUP_ENABLE(0) | KL3_IT_PORT_RESUME_WAKE_EN(0) |
-                                KL3_IT_PORT_CONNECT_WAKE_EN(0) | KL3_IT_PORT_DISCONNECT_WAKE_EN(0);
-                        reg |=  KL3_IT_PORT_WAKEUP_ENABLE(1) | KL3_IT_PORT_RESUME_WAKE_EN(1) |
-                                KL3_IT_PORT_CONNECT_WAKE_EN(1) | KL3_IT_PORT_DISCONNECT_WAKE_EN(1);
-                        MACIO_OUT32(KEYLARGO_FCR3, reg);
-                        (void)MACIO_IN32(KEYLARGO_FCR3);
-                        udelay(1);
-                }
-                if (number == 0) {
-                        if (macio->type != macio_intrepid)
-                                MACIO_BIC(KEYLARGO_FCR0, KL0_USB0_CELL_ENABLE);
-                        (void)MACIO_IN32(KEYLARGO_FCR0);
-                        udelay(1);
-                        MACIO_BIS(KEYLARGO_FCR0, (KL0_USB0_PAD_SUSPEND0 | KL0_USB0_PAD_SUSPEND1));
-                        (void)MACIO_IN32(KEYLARGO_FCR0);
-                } else if (number == 2) {
-                        if (macio->type != macio_intrepid)
-                                MACIO_BIC(KEYLARGO_FCR0, KL0_USB1_CELL_ENABLE);
-                        (void)MACIO_IN32(KEYLARGO_FCR0);
-                        udelay(1);
-                        MACIO_BIS(KEYLARGO_FCR0, (KL0_USB1_PAD_SUSPEND0 | KL0_USB1_PAD_SUSPEND1));
-                        (void)MACIO_IN32(KEYLARGO_FCR0);
-                } else if (number == 4) {
-                        udelay(1);
-                        MACIO_BIS(KEYLARGO_FCR1, (KL1_USB2_PAD_SUSPEND0 | KL1_USB2_PAD_SUSPEND1));
-                        (void)MACIO_IN32(KEYLARGO_FCR1);
-                }
-                udelay(1);
-        }
-        UNLOCK(flags);
-
-        return 0;
-}
-
-static long
-core99_firewire_enable(struct device_node* node, long param, long value)
-{
-        unsigned long flags;
-        struct macio_chip* macio;
-
-        macio = &macio_chips[0];
-        if (macio->type != macio_keylargo && macio->type != macio_pangea &&
-            macio->type != macio_intrepid)
-                return -ENODEV;
-        if (!(macio->flags & MACIO_FLAG_FW_SUPPORTED))
-                return -ENODEV;
-
-        LOCK(flags);
-        if (value) {
-                UN_BIS(UNI_N_CLOCK_CNTL, UNI_N_CLOCK_CNTL_FW);
-                (void)UN_IN(UNI_N_CLOCK_CNTL);
-        } else {
-                UN_BIC(UNI_N_CLOCK_CNTL, UNI_N_CLOCK_CNTL_FW);
-                (void)UN_IN(UNI_N_CLOCK_CNTL);
-        }
-        UNLOCK(flags);
-        mdelay(1);
-
-        return 0;
-}
-
-static long
-core99_firewire_cable_power(struct device_node* node, long param, long value)
-{
-        unsigned long flags;
-        struct macio_chip* macio;
-
-        /* Trick: we allow NULL node */
-        if ((pmac_mb.board_flags & PMAC_MB_HAS_FW_POWER) == 0)
-                return -ENODEV;
-        macio = &macio_chips[0];
-        if (macio->type != macio_keylargo && macio->type != macio_pangea &&
-            macio->type != macio_intrepid)
-                return -ENODEV;
-        if (!(macio->flags & MACIO_FLAG_FW_SUPPORTED))
-                return -ENODEV;
-
-        LOCK(flags);
-        if (value) {
-                MACIO_OUT8(KL_GPIO_FW_CABLE_POWER , 0);
-                MACIO_IN8(KL_GPIO_FW_CABLE_POWER);
-                udelay(10);
-        } else {
-                MACIO_OUT8(KL_GPIO_FW_CABLE_POWER , 4);
-                MACIO_IN8(KL_GPIO_FW_CABLE_POWER); udelay(10);
-        }
-        UNLOCK(flags);
-        mdelay(1);
-
-        return 0;
-}
-
-static long
-intrepid_aack_delay_enable(struct device_node* node, long param, long value)
-{
-        unsigned long flags;
-
-        if (uninorth_rev < 0xd2)
-                return -ENODEV;
-
-        LOCK(flags);
-        if (param)
-                UN_BIS(UNI_N_AACK_DELAY, UNI_N_AACK_DELAY_ENABLE);
-        else
-                UN_BIC(UNI_N_AACK_DELAY, UNI_N_AACK_DELAY_ENABLE);
-        UNLOCK(flags);
-
-        return 0;
-}
-
-
-#endif /* CONFIG_POWER4 */
-
-static long
-core99_read_gpio(struct device_node* node, long param, long value)
-{
-        struct macio_chip* macio = &macio_chips[0];
-
-        return MACIO_IN8(param);
-}
-
-
-static long
-core99_write_gpio(struct device_node* node, long param, long value)
-{
-        struct macio_chip* macio = &macio_chips[0];
-
-        MACIO_OUT8(param, (u8)(value & 0xff));
-        return 0;
-}
-
-#ifdef CONFIG_POWER4
-
-static long
-g5_gmac_enable(struct device_node* node, long param, long value)
-{
-        struct macio_chip* macio = &macio_chips[0];
-        unsigned long flags;
-        u8 pbus, pid;
-
-        LOCK(flags);
-        if (value) {
-                MACIO_BIS(KEYLARGO_FCR1, K2_FCR1_GMAC_CLK_ENABLE);
-                mb();
-                k2_skiplist[0] = NULL;
-        } else {
-                k2_skiplist[0] = node;
-                mb();
-                MACIO_BIC(KEYLARGO_FCR1, K2_FCR1_GMAC_CLK_ENABLE);
-        }
-        
-        UNLOCK(flags);
-        mdelay(1);
-
-        return 0;
-}
-
-static long
-g5_fw_enable(struct device_node* node, long param, long value)
-{
-        struct macio_chip* macio = &macio_chips[0];
-        unsigned long flags;
-
-        LOCK(flags);
-        if (value) {
-                MACIO_BIS(KEYLARGO_FCR1, K2_FCR1_FW_CLK_ENABLE);
-                mb();
-                k2_skiplist[1] = NULL;
-        } else {
-                k2_skiplist[1] = node;
-                mb();
-                MACIO_BIC(KEYLARGO_FCR1, K2_FCR1_FW_CLK_ENABLE);
-        }
-        
-        UNLOCK(flags);
-        mdelay(1);
-
-        return 0;
-}
-
-static long
-g5_mpic_enable(struct device_node* node, long param, long value)
-{
-        unsigned long flags;
-
-        if (node->parent == NULL || strcmp(node->parent->name, "u3"))
-                return 0;
-
-        LOCK(flags);
-        UN_BIS(U3_TOGGLE_REG, U3_MPIC_RESET | U3_MPIC_OUTPUT_ENABLE);
-        UNLOCK(flags);
-
-        return 0;
-}
-
-#ifdef CONFIG_SMP
-static long
-g5_reset_cpu(struct device_node* node, long param, long value)
-{
-        unsigned int reset_io = 0;
-        unsigned long flags;
-        struct macio_chip* macio;
-        struct device_node* np;
-
-        macio = &macio_chips[0];
-        if (macio->type != macio_keylargo2)
-                return -ENODEV;
-
-        np = find_path_device("/cpus");
-        if (np == NULL)
-                return -ENODEV;
-        for (np = np->child; np != NULL; np = np->sibling) {
-                u32* num = (u32 *)get_property(np, "reg", NULL);
-                u32* rst = (u32 *)get_property(np, "soft-reset", NULL);
-                if (num == NULL || rst == NULL)
-                        continue;
-                if (param == *num) {
-                        reset_io = *rst;
-                        break;
-                }
-        }
-        if (np == NULL || reset_io == 0)
-                return -ENODEV;
-
-        LOCK(flags);
-        MACIO_OUT8(reset_io, KEYLARGO_GPIO_OUTPUT_ENABLE);
-        (void)MACIO_IN8(reset_io);
-        udelay(1);
-        MACIO_OUT8(reset_io, 0);
-        (void)MACIO_IN8(reset_io);
-        UNLOCK(flags);
-
-        return 0;
-}
-#endif /* CONFIG_SMP */
-
-/*
- * This can be called from pmac_smp so isn't static
- *
- * This takes the second CPU off the bus on dual CPU machines
- * running UP
- */
-void g5_phy_disable_cpu1(void)
-{
-        UN_OUT(U3_API_PHY_CONFIG_1, 0);
-}
-
-#endif /* CONFIG_POWER4 */
-
-#ifndef CONFIG_POWER4
-
-static void
-keylargo_shutdown(struct macio_chip* macio, int sleep_mode)
-{
-        u32 temp;
-
-        if (sleep_mode) {
-                mdelay(1);
-                MACIO_BIS(KEYLARGO_FCR0, KL0_USB_REF_SUSPEND);
-                (void)MACIO_IN32(KEYLARGO_FCR0);
-                mdelay(1);
-        }
-
-        MACIO_BIC(KEYLARGO_FCR0,KL0_SCCA_ENABLE | KL0_SCCB_ENABLE |
-                                KL0_SCC_CELL_ENABLE |
-                                KL0_IRDA_ENABLE | KL0_IRDA_CLK32_ENABLE |
-                                KL0_IRDA_CLK19_ENABLE);
-
-        MACIO_BIC(KEYLARGO_MBCR, KL_MBCR_MB0_DEV_MASK);
-        MACIO_BIS(KEYLARGO_MBCR, KL_MBCR_MB0_IDE_ENABLE);
-
-        MACIO_BIC(KEYLARGO_FCR1,
-                KL1_AUDIO_SEL_22MCLK | KL1_AUDIO_CLK_ENABLE_BIT |
-                KL1_AUDIO_CLK_OUT_ENABLE | KL1_AUDIO_CELL_ENABLE |
-                KL1_I2S0_CELL_ENABLE | KL1_I2S0_CLK_ENABLE_BIT |
-                KL1_I2S0_ENABLE | KL1_I2S1_CELL_ENABLE |
-                KL1_I2S1_CLK_ENABLE_BIT | KL1_I2S1_ENABLE |
-                KL1_EIDE0_ENABLE | KL1_EIDE0_RESET_N |
-                KL1_EIDE1_ENABLE | KL1_EIDE1_RESET_N |
-                KL1_UIDE_ENABLE);
-
-        MACIO_BIS(KEYLARGO_FCR2, KL2_ALT_DATA_OUT);
-        MACIO_BIC(KEYLARGO_FCR2, KL2_IOBUS_ENABLE);
-
-        temp = MACIO_IN32(KEYLARGO_FCR3);
-        if (macio->rev >= 2) {
-                temp |= KL3_SHUTDOWN_PLL2X;
-                if (sleep_mode)
-                        temp |= KL3_SHUTDOWN_PLL_TOTAL;
-        }
-
-        temp |= KL3_SHUTDOWN_PLLKW6 | KL3_SHUTDOWN_PLLKW4 |
-                KL3_SHUTDOWN_PLLKW35;
-        if (sleep_mode)
-                temp |= KL3_SHUTDOWN_PLLKW12;
-        temp &= ~(KL3_CLK66_ENABLE | KL3_CLK49_ENABLE | KL3_CLK45_ENABLE
-                | KL3_CLK31_ENABLE | KL3_I2S1_CLK18_ENABLE | KL3_I2S0_CLK18_ENABLE);
-        if (sleep_mode)
-                temp &= ~(KL3_TIMER_CLK18_ENABLE | KL3_VIA_CLK16_ENABLE);
-        MACIO_OUT32(KEYLARGO_FCR3, temp);
-
-        /* Flush posted writes & wait a bit */
-        (void)MACIO_IN32(KEYLARGO_FCR0); mdelay(1);
-}
-
-static void
-pangea_shutdown(struct macio_chip* macio, int sleep_mode)
-{
-        u32 temp;
-
-        MACIO_BIC(KEYLARGO_FCR0,KL0_SCCA_ENABLE | KL0_SCCB_ENABLE |
-                                KL0_SCC_CELL_ENABLE |
-                                KL0_USB0_CELL_ENABLE | KL0_USB1_CELL_ENABLE);
-
-        MACIO_BIC(KEYLARGO_FCR1,
-                KL1_AUDIO_SEL_22MCLK | KL1_AUDIO_CLK_ENABLE_BIT |
-                KL1_AUDIO_CLK_OUT_ENABLE | KL1_AUDIO_CELL_ENABLE |
-                KL1_I2S0_CELL_ENABLE | KL1_I2S0_CLK_ENABLE_BIT |
-                KL1_I2S0_ENABLE | KL1_I2S1_CELL_ENABLE |
-                KL1_I2S1_CLK_ENABLE_BIT | KL1_I2S1_ENABLE |
-                KL1_UIDE_ENABLE);
-        if (pmac_mb.board_flags & PMAC_MB_MOBILE)
-                MACIO_BIC(KEYLARGO_FCR1, KL1_UIDE_RESET_N);
-
-        MACIO_BIS(KEYLARGO_FCR2, KL2_ALT_DATA_OUT);
-
-        temp = MACIO_IN32(KEYLARGO_FCR3);
-        temp |= KL3_SHUTDOWN_PLLKW6 | KL3_SHUTDOWN_PLLKW4 |
-                KL3_SHUTDOWN_PLLKW35;
-        temp &= ~(KL3_CLK49_ENABLE | KL3_CLK45_ENABLE | KL3_CLK31_ENABLE
-                | KL3_I2S0_CLK18_ENABLE | KL3_I2S1_CLK18_ENABLE);
-        if (sleep_mode)
-                temp &= ~(KL3_VIA_CLK16_ENABLE | KL3_TIMER_CLK18_ENABLE);
-        MACIO_OUT32(KEYLARGO_FCR3, temp);
-
-        /* Flush posted writes & wait a bit */
-        (void)MACIO_IN32(KEYLARGO_FCR0); mdelay(1);
-}
-
-static void
-intrepid_shutdown(struct macio_chip* macio, int sleep_mode)
-{
-        u32 temp;
-
-        MACIO_BIC(KEYLARGO_FCR0,KL0_SCCA_ENABLE | KL0_SCCB_ENABLE |
-                  KL0_SCC_CELL_ENABLE);
-
-        MACIO_BIC(KEYLARGO_FCR1,
-                  /*KL1_USB2_CELL_ENABLE |*/
-                KL1_I2S0_CELL_ENABLE | KL1_I2S0_CLK_ENABLE_BIT |
-                KL1_I2S0_ENABLE | KL1_I2S1_CELL_ENABLE |
-                KL1_I2S1_CLK_ENABLE_BIT | KL1_I2S1_ENABLE);
-        if (pmac_mb.board_flags & PMAC_MB_MOBILE)
-                MACIO_BIC(KEYLARGO_FCR1, KL1_UIDE_RESET_N);
-
-        temp = MACIO_IN32(KEYLARGO_FCR3);
-        temp &= ~(KL3_CLK49_ENABLE | KL3_CLK45_ENABLE |
-                  KL3_I2S1_CLK18_ENABLE | KL3_I2S0_CLK18_ENABLE);
-        if (sleep_mode)
-                temp &= ~(KL3_TIMER_CLK18_ENABLE | KL3_IT_VIA_CLK32_ENABLE);
-        MACIO_OUT32(KEYLARGO_FCR3, temp);
-
-        /* Flush posted writes & wait a bit */
-        (void)MACIO_IN32(KEYLARGO_FCR0);
-        mdelay(10);
-}
-
-
-void pmac_tweak_clock_spreading(int enable)
-{
-        struct macio_chip* macio = &macio_chips[0];
-
-        /* Hack for doing clock spreading on some machines PowerBooks and
-         * iBooks. This implements the "platform-do-clockspreading" OF
-         * property as decoded manually on various models. For safety, we also
-         * check the product ID in the device-tree in cases we'll whack the i2c
-         * chip to make reasonably sure we won't set wrong values in there
-         *
-         * Of course, ultimately, we have to implement a real parser for
-         * the platform-do-* stuff...
-         */
-
-        if (macio->type == macio_intrepid) {
-                struct device_node *clock =
-                        of_find_node_by_path("/uni-n@f8000000/hw-clock");
-                if (clock && get_property(clock, "platform-do-clockspreading",
-                                          NULL)) {
-                        printk(KERN_INFO "%sabling clock spreading on Intrepid"
-                               " ASIC\n", enable ? "En" : "Dis");
-                        if (enable)
-                                UN_OUT(UNI_N_CLOCK_SPREADING, 2);
-                        else
-                                UN_OUT(UNI_N_CLOCK_SPREADING, 0);
-                        mdelay(40);
-                }
-                of_node_put(clock);
-        }
-
-        while (machine_is_compatible("PowerBook5,2") ||
-               machine_is_compatible("PowerBook5,3") ||
-               machine_is_compatible("PowerBook6,2") ||
-               machine_is_compatible("PowerBook6,3")) {
-                struct device_node *ui2c = of_find_node_by_type(NULL, "i2c");
-                struct device_node *dt = of_find_node_by_name(NULL, "device-tree");
-                u8 buffer[9];
-                u32 *productID;
-                int i, rc, changed = 0;
-
-                if (dt == NULL)
-                        break;
-                productID = (u32 *)get_property(dt, "pid#", NULL);
-                if (productID == NULL)
-                        break;
-                while(ui2c) {
-                        struct device_node *p = of_get_parent(ui2c);
-                        if (p && !strcmp(p->name, "uni-n"))
-                                break;
-                        ui2c = of_find_node_by_type(ui2c, "i2c");
-                }
-                if (ui2c == NULL)
-                        break;
-                DBG("Trying to bump clock speed for PID: %08x...\n", *productID);
-                rc = pmac_low_i2c_open(ui2c, 1);
-                if (rc != 0)
-                        break;
-                pmac_low_i2c_setmode(ui2c, pmac_low_i2c_mode_combined);
-                rc = pmac_low_i2c_xfer(ui2c, 0xd2 | pmac_low_i2c_read, 0x80, buffer, 9);
-                DBG("read result: %d,", rc);
-                if (rc != 0) {
-                        pmac_low_i2c_close(ui2c);
-                        break;
-                }
-                for (i=0; i<9; i++)
-                        DBG(" %02x", buffer[i]);
-                DBG("\n");
-
-                switch(*productID) {
-                case 0x1182:    /* AlBook 12" rev 2 */
-                case 0x1183:    /* iBook G4 12" */
-                        buffer[0] = (buffer[0] & 0x8f) | 0x70;
-                        buffer[2] = (buffer[2] & 0x7f) | 0x00;
-                        buffer[5] = (buffer[5] & 0x80) | 0x31;
-                        buffer[6] = (buffer[6] & 0x40) | 0xb0;
-                        buffer[7] = (buffer[7] & 0x00) | (enable ? 0xc0 : 0xba);
-                        buffer[8] = (buffer[8] & 0x00) | 0x30;
-                        changed = 1;
-                        break;
-                case 0x3142:    /* AlBook 15" (ATI M10) */
-                case 0x3143:    /* AlBook 17" (ATI M10) */
-                        buffer[0] = (buffer[0] & 0xaf) | 0x50;
-                        buffer[2] = (buffer[2] & 0x7f) | 0x00;
-                        buffer[5] = (buffer[5] & 0x80) | 0x31;
-                        buffer[6] = (buffer[6] & 0x40) | 0xb0;
-                        buffer[7] = (buffer[7] & 0x00) | (enable ? 0xd0 : 0xc0);
-                        buffer[8] = (buffer[8] & 0x00) | 0x30;
-                        changed = 1;
-                        break;
-                default:
-                        DBG("i2c-hwclock: Machine model not handled\n");
-                        break;
-                }
-                if (!changed) {
-                        pmac_low_i2c_close(ui2c);
-                        break;
-                }
-                printk(KERN_INFO "%sabling clock spreading on i2c clock chip\n",
-                       enable ? "En" : "Dis");
-                pmac_low_i2c_setmode(ui2c, pmac_low_i2c_mode_stdsub);
-                rc = pmac_low_i2c_xfer(ui2c, 0xd2 | pmac_low_i2c_write, 0x80, buffer, 9);
-                DBG("write result: %d,", rc);
-                pmac_low_i2c_setmode(ui2c, pmac_low_i2c_mode_combined);
-                rc = pmac_low_i2c_xfer(ui2c, 0xd2 | pmac_low_i2c_read, 0x80, buffer, 9);
-                DBG("read result: %d,", rc);
-                if (rc != 0) {
-                        pmac_low_i2c_close(ui2c);
-                        break;
-                }
-                for (i=0; i<9; i++)
-                        DBG(" %02x", buffer[i]);
-                pmac_low_i2c_close(ui2c);
-                break;
-        }
-}
-
-
-static int
-core99_sleep(void)
-{
-        struct macio_chip* macio;
-        int i;
-
-        macio = &macio_chips[0];
-        if (macio->type != macio_keylargo && macio->type != macio_pangea &&
-            macio->type != macio_intrepid)
-                return -ENODEV;
-
-        /* We power off the wireless slot in case it was not done
-         * by the driver. We don't power it on automatically however
-         */
-        if (macio->flags & MACIO_FLAG_AIRPORT_ON)
-                core99_airport_enable(macio->of_node, 0, 0);
-
-        /* We power off the FW cable. Should be done by the driver... */
-        if (macio->flags & MACIO_FLAG_FW_SUPPORTED) {
-                core99_firewire_enable(NULL, 0, 0);
-                core99_firewire_cable_power(NULL, 0, 0);
-        }
-
-        /* We make sure int. modem is off (in case driver lost it) */
-        if (macio->type == macio_keylargo)
-                core99_modem_enable(macio->of_node, 0, 0);
-        else
-                pangea_modem_enable(macio->of_node, 0, 0);
-
-        /* We make sure the sound is off as well */
-        core99_sound_chip_enable(macio->of_node, 0, 0);
-
-        /*
-         * Save various bits of KeyLargo
-         */
-
-        /* Save the state of the various GPIOs */
-        save_gpio_levels[0] = MACIO_IN32(KEYLARGO_GPIO_LEVELS0);
-        save_gpio_levels[1] = MACIO_IN32(KEYLARGO_GPIO_LEVELS1);
-        for (i=0; i<KEYLARGO_GPIO_EXTINT_CNT; i++)
-                save_gpio_extint[i] = MACIO_IN8(KEYLARGO_GPIO_EXTINT_0+i);
-        for (i=0; i<KEYLARGO_GPIO_CNT; i++)
-                save_gpio_normal[i] = MACIO_IN8(KEYLARGO_GPIO_0+i);
-
-        /* Save the FCRs */
-        if (macio->type == macio_keylargo)
-                save_mbcr = MACIO_IN32(KEYLARGO_MBCR);
-        save_fcr[0] = MACIO_IN32(KEYLARGO_FCR0);
-        save_fcr[1] = MACIO_IN32(KEYLARGO_FCR1);
-        save_fcr[2] = MACIO_IN32(KEYLARGO_FCR2);
-        save_fcr[3] = MACIO_IN32(KEYLARGO_FCR3);
-        save_fcr[4] = MACIO_IN32(KEYLARGO_FCR4);
-        if (macio->type == macio_pangea || macio->type == macio_intrepid)
-                save_fcr[5] = MACIO_IN32(KEYLARGO_FCR5);
-
-        /* Save state & config of DBDMA channels */
-        dbdma_save(macio, save_dbdma);
-
-        /*
-         * Turn off as much as we can
-         */
-        if (macio->type == macio_pangea)
-                pangea_shutdown(macio, 1);
-        else if (macio->type == macio_intrepid)
-                intrepid_shutdown(macio, 1);
-        else if (macio->type == macio_keylargo)
-                keylargo_shutdown(macio, 1);
-
-        /*
-         * Put the host bridge to sleep
-         */
-
-        save_unin_clock_ctl = UN_IN(UNI_N_CLOCK_CNTL);
-        /* Note: do not switch GMAC off, driver does it when necessary, WOL must keep it
-         * enabled !
-         */
-        UN_OUT(UNI_N_CLOCK_CNTL, save_unin_clock_ctl &
-               ~(/*UNI_N_CLOCK_CNTL_GMAC|*/UNI_N_CLOCK_CNTL_FW/*|UNI_N_CLOCK_CNTL_PCI*/));
-        udelay(100);
-        UN_OUT(UNI_N_HWINIT_STATE, UNI_N_HWINIT_STATE_SLEEPING);
-        UN_OUT(UNI_N_POWER_MGT, UNI_N_POWER_MGT_SLEEP);
-        mdelay(10);
-
-        /*
-         * FIXME: A bit of black magic with OpenPIC (don't ask me why)
-         */
-        if (pmac_mb.model_id == PMAC_TYPE_SAWTOOTH) {
-                MACIO_BIS(0x506e0, 0x00400000);
-                MACIO_BIS(0x506e0, 0x80000000);
-        }
-        return 0;
-}
-
-static int
-core99_wake_up(void)
-{
-        struct macio_chip* macio;
-        int i;
-
-        macio = &macio_chips[0];
-        if (macio->type != macio_keylargo && macio->type != macio_pangea &&
-            macio->type != macio_intrepid)
-                return -ENODEV;
-
-        /*
-         * Wakeup the host bridge
-         */
-        UN_OUT(UNI_N_POWER_MGT, UNI_N_POWER_MGT_NORMAL);
-        udelay(10);
-        UN_OUT(UNI_N_HWINIT_STATE, UNI_N_HWINIT_STATE_RUNNING);
-        udelay(10);
-
-        /*
-         * Restore KeyLargo
-         */
-
-        if (macio->type == macio_keylargo) {
-                MACIO_OUT32(KEYLARGO_MBCR, save_mbcr);
-                (void)MACIO_IN32(KEYLARGO_MBCR); udelay(10);
-        }
-        MACIO_OUT32(KEYLARGO_FCR0, save_fcr[0]);
-        (void)MACIO_IN32(KEYLARGO_FCR0); udelay(10);
-        MACIO_OUT32(KEYLARGO_FCR1, save_fcr[1]);
-        (void)MACIO_IN32(KEYLARGO_FCR1); udelay(10);
-        MACIO_OUT32(KEYLARGO_FCR2, save_fcr[2]);
-        (void)MACIO_IN32(KEYLARGO_FCR2); udelay(10);
-        MACIO_OUT32(KEYLARGO_FCR3, save_fcr[3]);
-        (void)MACIO_IN32(KEYLARGO_FCR3); udelay(10);
-        MACIO_OUT32(KEYLARGO_FCR4, save_fcr[4]);
-        (void)MACIO_IN32(KEYLARGO_FCR4); udelay(10);
-        if (macio->type == macio_pangea || macio->type == macio_intrepid) {
-                MACIO_OUT32(KEYLARGO_FCR5, save_fcr[5]);
-                (void)MACIO_IN32(KEYLARGO_FCR5); udelay(10);
-        }
-
-        dbdma_restore(macio, save_dbdma);
-
-        MACIO_OUT32(KEYLARGO_GPIO_LEVELS0, save_gpio_levels[0]);
-        MACIO_OUT32(KEYLARGO_GPIO_LEVELS1, save_gpio_levels[1]);
-        for (i=0; i<KEYLARGO_GPIO_EXTINT_CNT; i++)
-                MACIO_OUT8(KEYLARGO_GPIO_EXTINT_0+i, save_gpio_extint[i]);
-        for (i=0; i<KEYLARGO_GPIO_CNT; i++)
-                MACIO_OUT8(KEYLARGO_GPIO_0+i, save_gpio_normal[i]);
-
-        /* FIXME more black magic with OpenPIC ... */
-        if (pmac_mb.model_id == PMAC_TYPE_SAWTOOTH) {
-                MACIO_BIC(0x506e0, 0x00400000);
-                MACIO_BIC(0x506e0, 0x80000000);
-        }
-
-        UN_OUT(UNI_N_CLOCK_CNTL, save_unin_clock_ctl);
-        udelay(100);
-
-        return 0;
-}
-
-static long
-core99_sleep_state(struct device_node* node, long param, long value)
-{
-        /* Param == 1 means to enter the "fake sleep" mode that is
-         * used for CPU speed switch
-         */
-        if (param == 1) {
-                if (value == 1) {
-                        UN_OUT(UNI_N_HWINIT_STATE, UNI_N_HWINIT_STATE_SLEEPING);
-                        UN_OUT(UNI_N_POWER_MGT, UNI_N_POWER_MGT_IDLE2);
-                } else {
-                        UN_OUT(UNI_N_POWER_MGT, UNI_N_POWER_MGT_NORMAL);
-                        udelay(10);
-                        UN_OUT(UNI_N_HWINIT_STATE, UNI_N_HWINIT_STATE_RUNNING);
-                        udelay(10);
-                }
-                return 0;
-        }
-        if ((pmac_mb.board_flags & PMAC_MB_CAN_SLEEP) == 0)
-                return -EPERM;
-
-        if (value == 1)
-                return core99_sleep();
-        else if (value == 0)
-                return core99_wake_up();
-        return 0;
-}
-
-#endif /* CONFIG_POWER4 */
-
-static long
-generic_dev_can_wake(struct device_node* node, long param, long value)
-{
-        /* Todo: eventually check we are really dealing with on-board
-         * video device ...
-         */
-
-        if (pmac_mb.board_flags & PMAC_MB_MAY_SLEEP)
-                pmac_mb.board_flags |= PMAC_MB_CAN_SLEEP;
-        return 0;
-}
-
-static long
-generic_get_mb_info(struct device_node* node, long param, long value)
-{
-        switch(param) {
-                case PMAC_MB_INFO_MODEL:
-                        return pmac_mb.model_id;
-                case PMAC_MB_INFO_FLAGS:
-                        return pmac_mb.board_flags;
-                case PMAC_MB_INFO_NAME:
-                        /* hack hack hack... but should work */
-                        *((const char **)value) = pmac_mb.model_name;
-                        return 0;
-        }
-        return -EINVAL;
-}
-
-
-/*
- * Table definitions
- */
-
-/* Used on any machine
- */
-static struct feature_table_entry any_features[] = {
-        { PMAC_FTR_GET_MB_INFO,         generic_get_mb_info },
-        { PMAC_FTR_DEVICE_CAN_WAKE,     generic_dev_can_wake },
-        { 0, NULL }
-};
-
-#ifndef CONFIG_POWER4
-
-/* OHare based motherboards. Currently, we only use these on the
- * 2400,3400 and 3500 series powerbooks. Some older desktops seem
- * to have issues with turning on/off those asic cells
- */
-static struct feature_table_entry ohare_features[] = {
-        { PMAC_FTR_SCC_ENABLE,          ohare_htw_scc_enable },
-        { PMAC_FTR_SWIM3_ENABLE,        ohare_floppy_enable },
-        { PMAC_FTR_MESH_ENABLE,         ohare_mesh_enable },
-        { PMAC_FTR_IDE_ENABLE,          ohare_ide_enable},
-        { PMAC_FTR_IDE_RESET,           ohare_ide_reset},
-        { PMAC_FTR_SLEEP_STATE,         ohare_sleep_state },
-        { 0, NULL }
-};
-
-/* Heathrow desktop machines (Beige G3).
- * Separated as some features couldn't be properly tested
- * and the serial port control bits appear to confuse it.
- */
-static struct feature_table_entry heathrow_desktop_features[] = {
-        { PMAC_FTR_SWIM3_ENABLE,        heathrow_floppy_enable },
-        { PMAC_FTR_MESH_ENABLE,         heathrow_mesh_enable },
-        { PMAC_FTR_IDE_ENABLE,          heathrow_ide_enable },
-        { PMAC_FTR_IDE_RESET,           heathrow_ide_reset },
-        { PMAC_FTR_BMAC_ENABLE,         heathrow_bmac_enable },
-        { 0, NULL }
-};
-
-/* Heathrow based laptop, that is the Wallstreet and mainstreet
- * powerbooks.
- */
-static struct feature_table_entry heathrow_laptop_features[] = {
-        { PMAC_FTR_SCC_ENABLE,          ohare_htw_scc_enable },
-        { PMAC_FTR_MODEM_ENABLE,        heathrow_modem_enable },
-        { PMAC_FTR_SWIM3_ENABLE,        heathrow_floppy_enable },
-        { PMAC_FTR_MESH_ENABLE,         heathrow_mesh_enable },
-        { PMAC_FTR_IDE_ENABLE,          heathrow_ide_enable },
-        { PMAC_FTR_IDE_RESET,           heathrow_ide_reset },
-        { PMAC_FTR_BMAC_ENABLE,         heathrow_bmac_enable },
-        { PMAC_FTR_SOUND_CHIP_ENABLE,   heathrow_sound_enable },
-        { PMAC_FTR_SLEEP_STATE,         heathrow_sleep_state },
-        { 0, NULL }
-};
-
-/* Paddington based machines
- * The lombard (101) powerbook, first iMac models, B&W G3 and Yikes G4.
- */
-static struct feature_table_entry paddington_features[] = {
-        { PMAC_FTR_SCC_ENABLE,          ohare_htw_scc_enable },
-        { PMAC_FTR_MODEM_ENABLE,        heathrow_modem_enable },
-        { PMAC_FTR_SWIM3_ENABLE,        heathrow_floppy_enable },
-        { PMAC_FTR_MESH_ENABLE,         heathrow_mesh_enable },
-        { PMAC_FTR_IDE_ENABLE,          heathrow_ide_enable },
-        { PMAC_FTR_IDE_RESET,           heathrow_ide_reset },
-        { PMAC_FTR_BMAC_ENABLE,         heathrow_bmac_enable },
-        { PMAC_FTR_SOUND_CHIP_ENABLE,   heathrow_sound_enable },
-        { PMAC_FTR_SLEEP_STATE,         heathrow_sleep_state },
-        { 0, NULL }
-};
-
-/* Core99 & MacRISC 2 machines (all machines released since the
- * iBook (included), that is all AGP machines, except pangea
- * chipset. The pangea chipset is the "combo" UniNorth/KeyLargo
- * used on iBook2 & iMac "flow power".
- */
-static struct feature_table_entry core99_features[] = {
-        { PMAC_FTR_SCC_ENABLE,          core99_scc_enable },
-        { PMAC_FTR_MODEM_ENABLE,        core99_modem_enable },
-        { PMAC_FTR_IDE_ENABLE,          core99_ide_enable },
-        { PMAC_FTR_IDE_RESET,           core99_ide_reset },
-        { PMAC_FTR_GMAC_ENABLE,         core99_gmac_enable },
-        { PMAC_FTR_GMAC_PHY_RESET,      core99_gmac_phy_reset },
-        { PMAC_FTR_SOUND_CHIP_ENABLE,   core99_sound_chip_enable },
-        { PMAC_FTR_AIRPORT_ENABLE,      core99_airport_enable },
-        { PMAC_FTR_USB_ENABLE,          core99_usb_enable },
-        { PMAC_FTR_1394_ENABLE,         core99_firewire_enable },
-        { PMAC_FTR_1394_CABLE_POWER,    core99_firewire_cable_power },
-        { PMAC_FTR_SLEEP_STATE,         core99_sleep_state },
-#ifdef CONFIG_SMP
-        { PMAC_FTR_RESET_CPU,           core99_reset_cpu },
-#endif /* CONFIG_SMP */
-        { PMAC_FTR_READ_GPIO,           core99_read_gpio },
-        { PMAC_FTR_WRITE_GPIO,          core99_write_gpio },
-        { 0, NULL }
-};
-
-/* RackMac
- */
-static struct feature_table_entry rackmac_features[] = {
-        { PMAC_FTR_SCC_ENABLE,          core99_scc_enable },
-        { PMAC_FTR_IDE_ENABLE,          core99_ide_enable },
-        { PMAC_FTR_IDE_RESET,           core99_ide_reset },
-        { PMAC_FTR_GMAC_ENABLE,         core99_gmac_enable },
-        { PMAC_FTR_GMAC_PHY_RESET,      core99_gmac_phy_reset },
-        { PMAC_FTR_USB_ENABLE,          core99_usb_enable },
-        { PMAC_FTR_1394_ENABLE,         core99_firewire_enable },
-        { PMAC_FTR_1394_CABLE_POWER,    core99_firewire_cable_power },
-        { PMAC_FTR_SLEEP_STATE,         core99_sleep_state },
-#ifdef CONFIG_SMP
-        { PMAC_FTR_RESET_CPU,           core99_reset_cpu },
-#endif /* CONFIG_SMP */
-        { PMAC_FTR_READ_GPIO,           core99_read_gpio },
-        { PMAC_FTR_WRITE_GPIO,          core99_write_gpio },
-        { 0, NULL }
-};
-
-/* Pangea features
- */
-static struct feature_table_entry pangea_features[] = {
-        { PMAC_FTR_SCC_ENABLE,          core99_scc_enable },
-        { PMAC_FTR_MODEM_ENABLE,        pangea_modem_enable },
-        { PMAC_FTR_IDE_ENABLE,          core99_ide_enable },
-        { PMAC_FTR_IDE_RESET,           core99_ide_reset },
-        { PMAC_FTR_GMAC_ENABLE,         core99_gmac_enable },
-        { PMAC_FTR_GMAC_PHY_RESET,      core99_gmac_phy_reset },
-        { PMAC_FTR_SOUND_CHIP_ENABLE,   core99_sound_chip_enable },
-        { PMAC_FTR_AIRPORT_ENABLE,      core99_airport_enable },
-        { PMAC_FTR_USB_ENABLE,          core99_usb_enable },
-        { PMAC_FTR_1394_ENABLE,         core99_firewire_enable },
-        { PMAC_FTR_1394_CABLE_POWER,    core99_firewire_cable_power },
-        { PMAC_FTR_SLEEP_STATE,         core99_sleep_state },
-        { PMAC_FTR_READ_GPIO,           core99_read_gpio },
-        { PMAC_FTR_WRITE_GPIO,          core99_write_gpio },
-        { 0, NULL }
-};
-
-/* Intrepid features
- */
-static struct feature_table_entry intrepid_features[] = {
-        { PMAC_FTR_SCC_ENABLE,          core99_scc_enable },
-        { PMAC_FTR_MODEM_ENABLE,        pangea_modem_enable },
-        { PMAC_FTR_IDE_ENABLE,          core99_ide_enable },
-        { PMAC_FTR_IDE_RESET,           core99_ide_reset },
-        { PMAC_FTR_GMAC_ENABLE,         core99_gmac_enable },
-        { PMAC_FTR_GMAC_PHY_RESET,      core99_gmac_phy_reset },
-        { PMAC_FTR_SOUND_CHIP_ENABLE,   core99_sound_chip_enable },
-        { PMAC_FTR_AIRPORT_ENABLE,      core99_airport_enable },
-        { PMAC_FTR_USB_ENABLE,          core99_usb_enable },
-        { PMAC_FTR_1394_ENABLE,         core99_firewire_enable },
-        { PMAC_FTR_1394_CABLE_POWER,    core99_firewire_cable_power },
-        { PMAC_FTR_SLEEP_STATE,         core99_sleep_state },
-        { PMAC_FTR_READ_GPIO,           core99_read_gpio },
-        { PMAC_FTR_WRITE_GPIO,          core99_write_gpio },
-        { PMAC_FTR_AACK_DELAY_ENABLE,   intrepid_aack_delay_enable },
-        { 0, NULL }
-};
-
-#else /* CONFIG_POWER4 */
-
-/* G5 features
- */
-static struct feature_table_entry g5_features[] = {
-        { PMAC_FTR_GMAC_ENABLE,         g5_gmac_enable },
-        { PMAC_FTR_1394_ENABLE,         g5_fw_enable },
-        { PMAC_FTR_ENABLE_MPIC,         g5_mpic_enable },
-#ifdef CONFIG_SMP
-        { PMAC_FTR_RESET_CPU,           g5_reset_cpu },
-#endif /* CONFIG_SMP */
-        { PMAC_FTR_READ_GPIO,           core99_read_gpio },
-        { PMAC_FTR_WRITE_GPIO,          core99_write_gpio },
-        { 0, NULL }
-};
-
-#endif /* CONFIG_POWER4 */
-
-static struct pmac_mb_def pmac_mb_defs[] = {
-#ifndef CONFIG_POWER4
-        /*
-         * Desktops
-         */
-
-        {       "AAPL,8500",                    "PowerMac 8500/8600",
-                PMAC_TYPE_PSURGE,               NULL,
-                0
-        },
-        {       "AAPL,9500",                    "PowerMac 9500/9600",
-                PMAC_TYPE_PSURGE,               NULL,
-                0
-        },
-        {       "AAPL,7200",                    "PowerMac 7200",
-                PMAC_TYPE_PSURGE,               NULL,
-                0
-        },
-        {       "AAPL,7300",                    "PowerMac 7200/7300",
-                PMAC_TYPE_PSURGE,               NULL,
-                0
-        },
-        {       "AAPL,7500",                    "PowerMac 7500",
-                PMAC_TYPE_PSURGE,               NULL,
-                0
-        },
-        {       "AAPL,ShinerESB",               "Apple Network Server",
-                PMAC_TYPE_ANS,                  NULL,
-                0
-        },
-        {       "AAPL,e407",                    "Alchemy",
-                PMAC_TYPE_ALCHEMY,              NULL,
-                0
-        },
-        {       "AAPL,e411",                    "Gazelle",
-                PMAC_TYPE_GAZELLE,              NULL,
-                0
-        },
-        {       "AAPL,Gossamer",                "PowerMac G3 (Gossamer)",
-                PMAC_TYPE_GOSSAMER,             heathrow_desktop_features,
-                0
-        },
-        {       "AAPL,PowerMac G3",             "PowerMac G3 (Silk)",
-                PMAC_TYPE_SILK,                 heathrow_desktop_features,
-                0
-        },
-        {       "PowerMac1,1",                  "Blue&White G3",
-                PMAC_TYPE_YOSEMITE,             paddington_features,
-                0
-        },
-        {       "PowerMac1,2",                  "PowerMac G4 PCI Graphics",
-                PMAC_TYPE_YIKES,                paddington_features,
-                0
-        },
-        {       "PowerMac2,1",                  "iMac FireWire",
-                PMAC_TYPE_FW_IMAC,              core99_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_OLD_CORE99
-        },
-        {       "PowerMac2,2",                  "iMac FireWire",
-                PMAC_TYPE_FW_IMAC,              core99_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_OLD_CORE99
-        },
-        {       "PowerMac3,1",                  "PowerMac G4 AGP Graphics",
-                PMAC_TYPE_SAWTOOTH,             core99_features,
-                PMAC_MB_OLD_CORE99
-        },
-        {       "PowerMac3,2",                  "PowerMac G4 AGP Graphics",
-                PMAC_TYPE_SAWTOOTH,             core99_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_OLD_CORE99
-        },
-        {       "PowerMac3,3",                  "PowerMac G4 AGP Graphics",
-                PMAC_TYPE_SAWTOOTH,             core99_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_OLD_CORE99
-        },
-        {       "PowerMac3,4",                  "PowerMac G4 Silver",
-                PMAC_TYPE_QUICKSILVER,          core99_features,
-                PMAC_MB_MAY_SLEEP
-        },
-        {       "PowerMac3,5",                  "PowerMac G4 Silver",
-                PMAC_TYPE_QUICKSILVER,          core99_features,
-                PMAC_MB_MAY_SLEEP
-        },
-        {       "PowerMac3,6",                  "PowerMac G4 Windtunnel",
-                PMAC_TYPE_WINDTUNNEL,           core99_features,
-                PMAC_MB_MAY_SLEEP,
-        },
-        {       "PowerMac4,1",                  "iMac \"Flower Power\"",
-                PMAC_TYPE_PANGEA_IMAC,          pangea_features,
-                PMAC_MB_MAY_SLEEP
-        },
-        {       "PowerMac4,2",                  "Flat panel iMac",
-                PMAC_TYPE_FLAT_PANEL_IMAC,      pangea_features,
-                PMAC_MB_CAN_SLEEP
-        },
-        {       "PowerMac4,4",                  "eMac",
-                PMAC_TYPE_EMAC,                 core99_features,
-                PMAC_MB_MAY_SLEEP
-        },
-        {       "PowerMac5,1",                  "PowerMac G4 Cube",
-                PMAC_TYPE_CUBE,                 core99_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_OLD_CORE99
-        },
-        {       "PowerMac6,1",                  "Flat panel iMac",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP,
-        },
-        {       "PowerMac6,3",                  "Flat panel iMac",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP,
-        },
-        {       "PowerMac6,4",                  "eMac",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP,
-        },
-        {       "PowerMac10,1",                 "Mac mini",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER,
-        },
-        {       "iMac,1",                       "iMac (first generation)",
-                PMAC_TYPE_ORIG_IMAC,            paddington_features,
-                0
-        },
-
-        /*
-         * Xserve's
-         */
-
-        {       "RackMac1,1",                   "XServe",
-                PMAC_TYPE_RACKMAC,              rackmac_features,
-                0,
-        },
-        {       "RackMac1,2",                   "XServe rev. 2",
-                PMAC_TYPE_RACKMAC,              rackmac_features,
-                0,
-        },
-
-        /*
-         * Laptops
-         */
-
-        {       "AAPL,3400/2400",               "PowerBook 3400",
-                PMAC_TYPE_HOOPER,               ohare_features,
-                PMAC_MB_CAN_SLEEP | PMAC_MB_MOBILE
-        },
-        {       "AAPL,3500",                    "PowerBook 3500",
-                PMAC_TYPE_KANGA,                ohare_features,
-                PMAC_MB_CAN_SLEEP | PMAC_MB_MOBILE
-        },
-        {       "AAPL,PowerBook1998",           "PowerBook Wallstreet",
-                PMAC_TYPE_WALLSTREET,           heathrow_laptop_features,
-                PMAC_MB_CAN_SLEEP | PMAC_MB_MOBILE
-        },
-        {       "PowerBook1,1",                 "PowerBook 101 (Lombard)",
-                PMAC_TYPE_101_PBOOK,            paddington_features,
-                PMAC_MB_CAN_SLEEP | PMAC_MB_MOBILE
-        },
-        {       "PowerBook2,1",                 "iBook (first generation)",
-                PMAC_TYPE_ORIG_IBOOK,           core99_features,
-                PMAC_MB_CAN_SLEEP | PMAC_MB_OLD_CORE99 | PMAC_MB_MOBILE
-        },
-        {       "PowerBook2,2",                 "iBook FireWire",
-                PMAC_TYPE_FW_IBOOK,             core99_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER |
-                PMAC_MB_OLD_CORE99 | PMAC_MB_MOBILE
-        },
-        {       "PowerBook3,1",                 "PowerBook Pismo",
-                PMAC_TYPE_PISMO,                core99_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER |
-                PMAC_MB_OLD_CORE99 | PMAC_MB_MOBILE
-        },
-        {       "PowerBook3,2",                 "PowerBook Titanium",
-                PMAC_TYPE_TITANIUM,             core99_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE
-        },
-        {       "PowerBook3,3",                 "PowerBook Titanium II",
-                PMAC_TYPE_TITANIUM2,            core99_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE
-        },
-        {       "PowerBook3,4",                 "PowerBook Titanium III",
-                PMAC_TYPE_TITANIUM3,            core99_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE
-        },
-        {       "PowerBook3,5",                 "PowerBook Titanium IV",
-                PMAC_TYPE_TITANIUM4,            core99_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE
-        },
-        {       "PowerBook4,1",                 "iBook 2",
-                PMAC_TYPE_IBOOK2,               pangea_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE
-        },
-        {       "PowerBook4,2",                 "iBook 2",
-                PMAC_TYPE_IBOOK2,               pangea_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE
-        },
-        {       "PowerBook4,3",                 "iBook 2 rev. 2",
-                PMAC_TYPE_IBOOK2,               pangea_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE
-        },
-        {       "PowerBook5,1",                 "PowerBook G4 17\"",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE,
-        },
-        {       "PowerBook5,2",                 "PowerBook G4 15\"",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE,
-        },
-        {       "PowerBook5,3",                 "PowerBook G4 17\"",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE,
-        },
-        {       "PowerBook5,4",                 "PowerBook G4 15\"",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE,
-        },
-        {       "PowerBook5,5",                 "PowerBook G4 17\"",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE,
-        },
-        {       "PowerBook5,6",                 "PowerBook G4 15\"",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE,
-        },
-        {       "PowerBook5,7",                 "PowerBook G4 17\"",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE,
-        },
-        {       "PowerBook5,8",                 "PowerBook G4 15\"",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE,
-        },
-        {       "PowerBook5,9",                 "PowerBook G4 17\"",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE,
-        },
-        {       "PowerBook6,1",                 "PowerBook G4 12\"",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE,
-        },
-        {       "PowerBook6,2",                 "PowerBook G4",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE,
-        },
-        {       "PowerBook6,3",                 "iBook G4",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE,
-        },
-        {       "PowerBook6,4",                 "PowerBook G4 12\"",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE,
-        },
-        {       "PowerBook6,5",                 "iBook G4",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE,
-        },
-        {       "PowerBook6,7",                 "iBook G4",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE,
-        },
-        {       "PowerBook6,8",                 "PowerBook G4 12\"",
-                PMAC_TYPE_UNKNOWN_INTREPID,     intrepid_features,
-                PMAC_MB_MAY_SLEEP | PMAC_MB_HAS_FW_POWER | PMAC_MB_MOBILE,
-        },
-#else /* CONFIG_POWER4 */
-        {       "PowerMac7,2",                  "PowerMac G5",
-                PMAC_TYPE_POWERMAC_G5,          g5_features,
-                0,
-        },
-#endif /* CONFIG_POWER4 */
-};
-
-/*
- * The toplevel feature_call callback
- */
-long
-pmac_do_feature_call(unsigned int selector, ...)
-{
-        struct device_node* node;
-        long param, value;
-        int i;
-        feature_call func = NULL;
-        va_list args;
-
-        if (pmac_mb.features)
-                for (i=0; pmac_mb.features[i].function; i++)
-                        if (pmac_mb.features[i].selector == selector) {
-                                func = pmac_mb.features[i].function;
-                                break;
-                        }
-        if (!func)
-                for (i=0; any_features[i].function; i++)
-                        if (any_features[i].selector == selector) {
-                                func = any_features[i].function;
-                                break;
-                        }
-        if (!func)
-                return -ENODEV;
-
-        va_start(args, selector);
-        node = (struct device_node*)va_arg(args, void*);
-        param = va_arg(args, long);
-        value = va_arg(args, long);
-        va_end(args);
-
-        return func(node, param, value);
-}
-
-static int __init
-probe_motherboard(void)
-{
-        int i;
-        struct macio_chip* macio = &macio_chips[0];
-        const char* model = NULL;
-        struct device_node *dt;
-
-        /* Lookup known motherboard type in device-tree. First try an
-         * exact match on the "model" property, then try a "compatible"
-         * match is none is found.
-         */
-        dt = find_devices("device-tree");
-        if (dt != NULL)
-                model = (const char *) get_property(dt, "model", NULL);
-        for(i=0; model && i<(sizeof(pmac_mb_defs)/sizeof(struct pmac_mb_def)); i++) {
-            if (strcmp(model, pmac_mb_defs[i].model_string) == 0) {
-                pmac_mb = pmac_mb_defs[i];
-                goto found;
-            }
-        }
-        for(i=0; i<(sizeof(pmac_mb_defs)/sizeof(struct pmac_mb_def)); i++) {
-            if (machine_is_compatible(pmac_mb_defs[i].model_string)) {
-                pmac_mb = pmac_mb_defs[i];
-                goto found;
-            }
-        }
-
-        /* Fallback to selection depending on mac-io chip type */
-        switch(macio->type) {
-#ifndef CONFIG_POWER4
-            case macio_grand_central:
-                pmac_mb.model_id = PMAC_TYPE_PSURGE;
-                pmac_mb.model_name = "Unknown PowerSurge";
-                break;
-            case macio_ohare:
-                pmac_mb.model_id = PMAC_TYPE_UNKNOWN_OHARE;
-                pmac_mb.model_name = "Unknown OHare-based";
-                break;
-            case macio_heathrow:
-                pmac_mb.model_id = PMAC_TYPE_UNKNOWN_HEATHROW;
-                pmac_mb.model_name = "Unknown Heathrow-based";
-                pmac_mb.features = heathrow_desktop_features;
-                break;
-            case macio_paddington:
-                pmac_mb.model_id = PMAC_TYPE_UNKNOWN_PADDINGTON;
-                pmac_mb.model_name = "Unknown Paddington-based";
-                pmac_mb.features = paddington_features;
-                break;
-            case macio_keylargo:
-                pmac_mb.model_id = PMAC_TYPE_UNKNOWN_CORE99;
-                pmac_mb.model_name = "Unknown Keylargo-based";
-                pmac_mb.features = core99_features;
-                break;
-            case macio_pangea:
-                pmac_mb.model_id = PMAC_TYPE_UNKNOWN_PANGEA;
-                pmac_mb.model_name = "Unknown Pangea-based";
-                pmac_mb.features = pangea_features;
-                break;
-            case macio_intrepid:
-                pmac_mb.model_id = PMAC_TYPE_UNKNOWN_INTREPID;
-                pmac_mb.model_name = "Unknown Intrepid-based";
-                pmac_mb.features = intrepid_features;
-                break;
-#else /* CONFIG_POWER4 */
-            case macio_keylargo2:
-                pmac_mb.model_id = PMAC_TYPE_UNKNOWN_K2;
-                pmac_mb.model_name = "Unknown G5";
-                pmac_mb.features = g5_features;
-                break;
-#endif /* CONFIG_POWER4 */
-            default:
-                return -ENODEV;
-        }
-found:
-#ifndef CONFIG_POWER4
-        /* Fixup Hooper vs. Comet */
-        if (pmac_mb.model_id == PMAC_TYPE_HOOPER) {
-                u32 __iomem * mach_id_ptr = ioremap(0xf3000034, 4);
-                if (!mach_id_ptr)
-                        return -ENODEV;
-                /* Here, I used to disable the media-bay on comet. It
-                 * appears this is wrong, the floppy connector is actually
-                 * a kind of media-bay and works with the current driver.
-                 */
-                if (__raw_readl(mach_id_ptr) & 0x20000000UL)
-                        pmac_mb.model_id = PMAC_TYPE_COMET;
-                iounmap(mach_id_ptr);
-        }
-#endif /* CONFIG_POWER4 */
-
-#ifdef CONFIG_6xx
-        /* Set default value of powersave_nap on machines that support it.
-         * It appears that uninorth rev 3 has a problem with it, we don't
-         * enable it on those. In theory, the flush-on-lock property is
-         * supposed to be set when not supported, but I'm not very confident
-         * that all Apple OF revs did it properly, I do it the paranoid way.
-         */
-        while (uninorth_base && uninorth_rev > 3) {
-                struct device_node* np = find_path_device("/cpus");
-                if (!np || !np->child) {
-                        printk(KERN_WARNING "Can't find CPU(s) in device tree !\n");
-                        break;
-                }
-                np = np->child;
-                /* Nap mode not supported on SMP */
-                if (np->sibling)
-                        break;
-                /* Nap mode not supported if flush-on-lock property is present */
-                if (get_property(np, "flush-on-lock", NULL))
-                        break;
-                powersave_nap = 1;
-                printk(KERN_INFO "Processor NAP mode on idle enabled.\n");
-                break;
-        }
-
-        /* On CPUs that support it (750FX), lowspeed by default during
-         * NAP mode
-         */
-        powersave_lowspeed = 1;
-#endif /* CONFIG_6xx */
-#ifdef CONFIG_POWER4
-        powersave_nap = 1;
-#endif
-        /* Check for "mobile" machine */
-        if (model && (strncmp(model, "PowerBook", 9) == 0
-                   || strncmp(model, "iBook", 5) == 0))
-                pmac_mb.board_flags |= PMAC_MB_MOBILE;
-
-
-        printk(KERN_INFO "PowerMac motherboard: %s\n", pmac_mb.model_name);
-        return 0;
-}
-
-/* Initialize the Core99 UniNorth host bridge and memory controller
- */
-static void __init
-probe_uninorth(void)
-{
-        unsigned long actrl;
-
-        /* Locate core99 Uni-N */
-        uninorth_node = of_find_node_by_name(NULL, "uni-n");
-        /* Locate G5 u3 */
-        if (uninorth_node == NULL) {
-                uninorth_node = of_find_node_by_name(NULL, "u3");
-                uninorth_u3 = 1;
-        }
-        if (uninorth_node && uninorth_node->n_addrs > 0) {
-                unsigned long address = uninorth_node->addrs[0].address;
-                uninorth_base = ioremap(address, 0x40000);
-                uninorth_rev = in_be32(UN_REG(UNI_N_VERSION));
-                if (uninorth_u3)
-                        u3_ht = ioremap(address + U3_HT_CONFIG_BASE, 0x1000);
-        } else
-                uninorth_node = NULL;
-
-        if (!uninorth_node)
-                return;
-
-        printk(KERN_INFO "Found %s memory controller & host bridge, revision: %d\n",
-               uninorth_u3 ? "U3" : "UniNorth", uninorth_rev);
-        printk(KERN_INFO "Mapped at 0x%08lx\n", (unsigned long)uninorth_base);
-
-        /* Set the arbitrer QAck delay according to what Apple does
-         */
-        if (uninorth_rev < 0x11) {
-                actrl = UN_IN(UNI_N_ARB_CTRL) & ~UNI_N_ARB_CTRL_QACK_DELAY_MASK;
-                actrl |= ((uninorth_rev < 3) ? UNI_N_ARB_CTRL_QACK_DELAY105 :
-                        UNI_N_ARB_CTRL_QACK_DELAY) << UNI_N_ARB_CTRL_QACK_DELAY_SHIFT;
-                UN_OUT(UNI_N_ARB_CTRL, actrl);
-        }
-
-        /* Some more magic as done by them in recent MacOS X on UniNorth
-         * revs 1.5 to 2.O and Pangea. Seem to toggle the UniN Maxbus/PCI
-         * memory timeout
-         */
-        if ((uninorth_rev >= 0x11 && uninorth_rev <= 0x24) || uninorth_rev == 0xc0)
-                UN_OUT(0x2160, UN_IN(0x2160) & 0x00ffffff);
-}
-
-static void __init
-probe_one_macio(const char* name, const char* compat, int type)
-{
-        struct device_node*     node;
-        int                     i;
-        volatile u32 __iomem *  base;
-        u32*                    revp;
-
-        node = find_devices(name);
-        if (!node || !node->n_addrs)
-                return;
-        if (compat)
-                do {
-                        if (device_is_compatible(node, compat))
-                                break;
-                        node = node->next;
-                } while (node);
-        if (!node)
-                return;
-        for(i=0; i<MAX_MACIO_CHIPS; i++) {
-                if (!macio_chips[i].of_node)
-                        break;
-                if (macio_chips[i].of_node == node)
-                        return;
-        }
-        if (i >= MAX_MACIO_CHIPS) {
-                printk(KERN_ERR "pmac_feature: Please increase MAX_MACIO_CHIPS !\n");
-                printk(KERN_ERR "pmac_feature: %s skipped\n", node->full_name);
-                return;
-        }
-        base = ioremap(node->addrs[0].address, node->addrs[0].size);
-        if (!base) {
-                printk(KERN_ERR "pmac_feature: Can't map mac-io chip !\n");
-                return;
-        }
-        if (type == macio_keylargo) {
-                u32* did = (u32 *)get_property(node, "device-id", NULL);
-                if (*did == 0x00000025)
-                        type = macio_pangea;
-                if (*did == 0x0000003e)
-                        type = macio_intrepid;
-        }
-        macio_chips[i].of_node  = node;
-        macio_chips[i].type     = type;
-        macio_chips[i].base     = base;
-        macio_chips[i].flags    = MACIO_FLAG_SCCB_ON | MACIO_FLAG_SCCB_ON;
-        macio_chips[i].name     = macio_names[type];
-        revp = (u32 *)get_property(node, "revision-id", NULL);
-        if (revp)
-                macio_chips[i].rev = *revp;
-        printk(KERN_INFO "Found a %s mac-io controller, rev: %d, mapped at 0x%p\n",
-                macio_names[type], macio_chips[i].rev, macio_chips[i].base);
-}
-
-static int __init
-probe_macios(void)
-{
-        /* Warning, ordering is important */
-        probe_one_macio("gc", NULL, macio_grand_central);
-        probe_one_macio("ohare", NULL, macio_ohare);
-        probe_one_macio("pci106b,7", NULL, macio_ohareII);
-        probe_one_macio("mac-io", "keylargo", macio_keylargo);
-        probe_one_macio("mac-io", "paddington", macio_paddington);
-        probe_one_macio("mac-io", "gatwick", macio_gatwick);
-        probe_one_macio("mac-io", "heathrow", macio_heathrow);
-        probe_one_macio("mac-io", "K2-Keylargo", macio_keylargo2);
-
-        /* Make sure the "main" macio chip appear first */
-        if (macio_chips[0].type == macio_gatwick
-            && macio_chips[1].type == macio_heathrow) {
-                struct macio_chip temp = macio_chips[0];
-                macio_chips[0] = macio_chips[1];
-                macio_chips[1] = temp;
-        }
-        if (macio_chips[0].type == macio_ohareII
-            && macio_chips[1].type == macio_ohare) {
-                struct macio_chip temp = macio_chips[0];
-                macio_chips[0] = macio_chips[1];
-                macio_chips[1] = temp;
-        }
-        macio_chips[0].lbus.index = 0;
-        macio_chips[1].lbus.index = 1;
-
-        return (macio_chips[0].of_node == NULL) ? -ENODEV : 0;
-}
-
-static void __init
-initial_serial_shutdown(struct device_node* np)
-{
-        int len;
-        struct slot_names_prop {
-                int     count;
-                char    name[1];
-        } *slots;
-        char *conn;
-        int port_type = PMAC_SCC_ASYNC;
-        int modem = 0;
-
-        slots = (struct slot_names_prop *)get_property(np, "slot-names", &len);
-        conn = get_property(np, "AAPL,connector", &len);
-        if (conn && (strcmp(conn, "infrared") == 0))
-                port_type = PMAC_SCC_IRDA;
-        else if (device_is_compatible(np, "cobalt"))
-                modem = 1;
-        else if (slots && slots->count > 0) {
-                if (strcmp(slots->name, "IrDA") == 0)
-                        port_type = PMAC_SCC_IRDA;
-                else if (strcmp(slots->name, "Modem") == 0)
-                        modem = 1;
-        }
-        if (modem)
-                pmac_call_feature(PMAC_FTR_MODEM_ENABLE, np, 0, 0);
-        pmac_call_feature(PMAC_FTR_SCC_ENABLE, np, port_type, 0);
-}
-
-static void __init
-set_initial_features(void)
-{
-        struct device_node* np;
-
-        /* That hack appears to be necessary for some StarMax motherboards
-         * but I'm not too sure it was audited for side-effects on other
-         * ohare based machines...
-         * Since I still have difficulties figuring the right way to
-         * differenciate them all and since that hack was there for a long
-         * time, I'll keep it around
-         */
-        if (macio_chips[0].type == macio_ohare && !find_devices("via-pmu")) {
-                struct macio_chip* macio = &macio_chips[0];
-                MACIO_OUT32(OHARE_FCR, STARMAX_FEATURES);
-        } else if (macio_chips[0].type == macio_ohare) {
-                struct macio_chip* macio = &macio_chips[0];
-                MACIO_BIS(OHARE_FCR, OH_IOBUS_ENABLE);
-        } else if (macio_chips[1].type == macio_ohare) {
-                struct macio_chip* macio = &macio_chips[1];
-                MACIO_BIS(OHARE_FCR, OH_IOBUS_ENABLE);
-        }
-
-#ifdef CONFIG_POWER4
-        if (macio_chips[0].type == macio_keylargo2) {
-#ifndef CONFIG_SMP
-                /* On SMP machines running UP, we have the second CPU eating
-                 * bus cycles. We need to take it off the bus. This is done
-                 * from pmac_smp for SMP kernels running on one CPU
-                 */
-                np = of_find_node_by_type(NULL, "cpu");
-                if (np != NULL)
-                        np = of_find_node_by_type(np, "cpu");
-                if (np != NULL) {
-                        g5_phy_disable_cpu1();
-                        of_node_put(np);
-                }
-#endif /* CONFIG_SMP */
-                /* Enable GMAC for now for PCI probing. It will be disabled
-                 * later on after PCI probe
-                 */
-                np = of_find_node_by_name(NULL, "ethernet");
-                while(np) {
-                        if (device_is_compatible(np, "K2-GMAC"))
-                                g5_gmac_enable(np, 0, 1);
-                        np = of_find_node_by_name(np, "ethernet");
-                }
-
-                /* Enable FW before PCI probe. Will be disabled later on
-                 * Note: We should have a batter way to check that we are
-                 * dealing with uninorth internal cell and not a PCI cell
-                 * on the external PCI. The code below works though.
-                 */
-                np = of_find_node_by_name(NULL, "firewire");
-                while(np) {
-                        if (device_is_compatible(np, "pci106b,5811")) {
-                                macio_chips[0].flags |= MACIO_FLAG_FW_SUPPORTED;
-                                g5_fw_enable(np, 0, 1);
-                        }
-                        np = of_find_node_by_name(np, "firewire");
-                }
-        }
-#else /* CONFIG_POWER4 */
-
-        if (macio_chips[0].type == macio_keylargo ||
-            macio_chips[0].type == macio_pangea ||
-            macio_chips[0].type == macio_intrepid) {
-                /* Enable GMAC for now for PCI probing. It will be disabled
-                 * later on after PCI probe
-                 */
-                np = of_find_node_by_name(NULL, "ethernet");
-                while(np) {
-                        if (np->parent
-                            && device_is_compatible(np->parent, "uni-north")
-                            && device_is_compatible(np, "gmac"))
-                                core99_gmac_enable(np, 0, 1);
-                        np = of_find_node_by_name(np, "ethernet");
-                }
-
-                /* Enable FW before PCI probe. Will be disabled later on
-                 * Note: We should have a batter way to check that we are
-                 * dealing with uninorth internal cell and not a PCI cell
-                 * on the external PCI. The code below works though.
-                 */
-                np = of_find_node_by_name(NULL, "firewire");
-                while(np) {
-                        if (np->parent
-                            && device_is_compatible(np->parent, "uni-north")
-                            && (device_is_compatible(np, "pci106b,18") ||
-                                device_is_compatible(np, "pci106b,30") ||
-                                device_is_compatible(np, "pci11c1,5811"))) {
-                                macio_chips[0].flags |= MACIO_FLAG_FW_SUPPORTED;
-                                core99_firewire_enable(np, 0, 1);
-                        }
-                        np = of_find_node_by_name(np, "firewire");
-                }
-
-                /* Enable ATA-100 before PCI probe. */
-                np = of_find_node_by_name(NULL, "ata-6");
-                while(np) {
-                        if (np->parent
-                            && device_is_compatible(np->parent, "uni-north")
-                            && device_is_compatible(np, "kauai-ata")) {
-                                core99_ata100_enable(np, 1);
-                        }
-                        np = of_find_node_by_name(np, "ata-6");
-                }
-
-                /* Switch airport off */
-                np = find_devices("radio");
-                while(np) {
-                        if (np && np->parent == macio_chips[0].of_node) {
-                                macio_chips[0].flags |= MACIO_FLAG_AIRPORT_ON;
-                                core99_airport_enable(np, 0, 0);
-                        }
-                        np = np->next;
-                }
-        }
-
-        /* On all machines that support sound PM, switch sound off */
-        if (macio_chips[0].of_node)
-                pmac_do_feature_call(PMAC_FTR_SOUND_CHIP_ENABLE,
-                        macio_chips[0].of_node, 0, 0);
-
-        /* While on some desktop G3s, we turn it back on */
-        if (macio_chips[0].of_node && macio_chips[0].type == macio_heathrow
-                && (pmac_mb.model_id == PMAC_TYPE_GOSSAMER ||
-                    pmac_mb.model_id == PMAC_TYPE_SILK)) {
-                struct macio_chip* macio = &macio_chips[0];
-                MACIO_BIS(HEATHROW_FCR, HRW_SOUND_CLK_ENABLE);
-                MACIO_BIC(HEATHROW_FCR, HRW_SOUND_POWER_N);
-        }
-
-        /* Some machine models need the clock chip to be properly setup for
-         * clock spreading now. This should be a platform function but we
-         * don't do these at the moment
-         */
-        pmac_tweak_clock_spreading(1);
-
-#endif /* CONFIG_POWER4 */
-
-        /* On all machines, switch modem & serial ports off */
-        np = find_devices("ch-a");
-        while(np) {
-                initial_serial_shutdown(np);
-                np = np->next;
-        }
-        np = find_devices("ch-b");
-        while(np) {
-                initial_serial_shutdown(np);
-                np = np->next;
-        }
-}
-
-void __init
-pmac_feature_init(void)
-{
-        /* Detect the UniNorth memory controller */
-        probe_uninorth();
-
-        /* Probe mac-io controllers */
-        if (probe_macios()) {
-                printk(KERN_WARNING "No mac-io chip found\n");
-                return;
-        }
-
-        /* Setup low-level i2c stuffs */
-        pmac_init_low_i2c();
-
-        /* Probe machine type */
-        if (probe_motherboard())
-                printk(KERN_WARNING "Unknown PowerMac !\n");
-
-        /* Set some initial features (turn off some chips that will
-         * be later turned on)
-         */
-        set_initial_features();
-}
-
-int __init
-pmac_feature_late_init(void)
-{
-        struct device_node* np;
-
-        /* Request some resources late */
-        if (uninorth_node)
-                request_OF_resource(uninorth_node, 0, NULL);
-        np = find_devices("hammerhead");
-        if (np)
-                request_OF_resource(np, 0, NULL);
-        np = find_devices("interrupt-controller");
-        if (np)
-                request_OF_resource(np, 0, NULL);
-        return 0;
-}
-
-device_initcall(pmac_feature_late_init);
-
-#ifdef CONFIG_POWER4
-
-static void dump_HT_speeds(char *name, u32 cfg, u32 frq)
-{
-        int     freqs[16] = { 200,300,400,500,600,800,1000,0,0,0,0,0,0,0,0,0 };
-        int     bits[8] = { 8,16,0,32,2,4,0,0 };
-        int     freq = (frq >> 8) & 0xf;
-
-        if (freqs[freq] == 0)
-                printk("%s: Unknown HT link frequency %x\n", name, freq);
-        else
-                printk("%s: %d MHz on main link, (%d in / %d out) bits width\n",
-                       name, freqs[freq],
-                       bits[(cfg >> 28) & 0x7], bits[(cfg >> 24) & 0x7]);
-}
-
-void __init pmac_check_ht_link(void)
-{
-        u32     ufreq, freq, ucfg, cfg;
-        struct device_node *pcix_node;
-        u8      px_bus, px_devfn;
-        struct pci_controller *px_hose;
-
-        (void)in_be32(u3_ht + U3_HT_LINK_COMMAND);
-        ucfg = cfg = in_be32(u3_ht + U3_HT_LINK_CONFIG);
-        ufreq = freq = in_be32(u3_ht + U3_HT_LINK_FREQ);
-        dump_HT_speeds("U3 HyperTransport", cfg, freq);
-
-        pcix_node = of_find_compatible_node(NULL, "pci", "pci-x");
-        if (pcix_node == NULL) {
-                printk("No PCI-X bridge found\n");
-                return;
-        }
-        if (pci_device_from_OF_node(pcix_node, &px_bus, &px_devfn) != 0) {
-                printk("PCI-X bridge found but not matched to pci\n");
-                return;
-        }
-        px_hose = pci_find_hose_for_OF_device(pcix_node);
-        if (px_hose == NULL) {
-                printk("PCI-X bridge found but not matched to host\n");
-                return;
-        }       
-        early_read_config_dword(px_hose, px_bus, px_devfn, 0xc4, &cfg);
-        early_read_config_dword(px_hose, px_bus, px_devfn, 0xcc, &freq);
-        dump_HT_speeds("PCI-X HT Uplink", cfg, freq);
-        early_read_config_dword(px_hose, px_bus, px_devfn, 0xc8, &cfg);
-        early_read_config_dword(px_hose, px_bus, px_devfn, 0xd0, &freq);
-        dump_HT_speeds("PCI-X HT Downlink", cfg, freq);
-}
-
-#endif /* CONFIG_POWER4 */
-
-/*
- * Early video resume hook
- */
-
-static void (*pmac_early_vresume_proc)(void *data);
-static void *pmac_early_vresume_data;
-
-void pmac_set_early_video_resume(void (*proc)(void *data), void *data)
-{
-        if (_machine != _MACH_Pmac)
-                return;
-        preempt_disable();
-        pmac_early_vresume_proc = proc;
-        pmac_early_vresume_data = data;
-        preempt_enable();
-}
-EXPORT_SYMBOL(pmac_set_early_video_resume);
-
-void pmac_call_early_video_resume(void)
-{
-        if (pmac_early_vresume_proc)
-                pmac_early_vresume_proc(pmac_early_vresume_data);
-}
-
-/*
- * AGP related suspend/resume code
- */
-
-static struct pci_dev *pmac_agp_bridge;
-static int (*pmac_agp_suspend)(struct pci_dev *bridge);
-static int (*pmac_agp_resume)(struct pci_dev *bridge);
-
-void pmac_register_agp_pm(struct pci_dev *bridge,
-                                 int (*suspend)(struct pci_dev *bridge),
-                                 int (*resume)(struct pci_dev *bridge))
-{
-        if (suspend || resume) {
-                pmac_agp_bridge = bridge;
-                pmac_agp_suspend = suspend;
-                pmac_agp_resume = resume;
-                return;
-        }
-        if (bridge != pmac_agp_bridge)
-                return;
-        pmac_agp_suspend = pmac_agp_resume = NULL;
-        return;
-}
-EXPORT_SYMBOL(pmac_register_agp_pm);
-
-void pmac_suspend_agp_for_card(struct pci_dev *dev)
-{
-        if (pmac_agp_bridge == NULL || pmac_agp_suspend == NULL)
-                return;
-        if (pmac_agp_bridge->bus != dev->bus)
-                return;
-        pmac_agp_suspend(pmac_agp_bridge);
-}
-EXPORT_SYMBOL(pmac_suspend_agp_for_card);
-
-void pmac_resume_agp_for_card(struct pci_dev *dev)
-{
-        if (pmac_agp_bridge == NULL || pmac_agp_resume == NULL)
-                return;
-        if (pmac_agp_bridge->bus != dev->bus)
-                return;
-        pmac_agp_resume(pmac_agp_bridge);
-}
-EXPORT_SYMBOL(pmac_resume_agp_for_card);
diff --git a/arch/ppc/platforms/pmac_low_i2c.c b/arch/ppc/platforms/pmac_low_i2c.c
deleted file mode 100644
index 08583fce1692..000000000000
--- a/arch/ppc/platforms/pmac_low_i2c.c
+++ /dev/null
@@ -1,511 +0,0 @@
-/*
- *  arch/ppc/platforms/pmac_low_i2c.c
- *
- *  Copyright (C) 2003 Ben. 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.
- *
- *  This file contains some low-level i2c access routines that
- *  need to be used by various bits of the PowerMac platform code
- *  at times where the real asynchronous & interrupt driven driver
- *  cannot be used. The API borrows some semantics from the darwin
- *  driver in order to ease the implementation of the platform
- *  properties parser
- */
-
-#include <linux/config.h>
-#include <linux/types.h>
-#include <linux/delay.h>
-#include <linux/sched.h>
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/adb.h>
-#include <linux/pmu.h>
-#include <asm/keylargo.h>
-#include <asm/uninorth.h>
-#include <asm/io.h>
-#include <asm/prom.h>
-#include <asm/machdep.h>
-#include <asm/pmac_low_i2c.h>
-
-#define MAX_LOW_I2C_HOST        4
-
-#if 1
-#define DBG(x...) do {\
-                printk(KERN_DEBUG "KW:" x);     \
-        } while(0)
-#else
-#define DBGG(x...)
-#endif
-
-struct low_i2c_host;
-
-typedef int (*low_i2c_func_t)(struct low_i2c_host *host, u8 addr, u8 sub, u8 *data, int len);
-
-struct low_i2c_host
-{
-        struct device_node      *np;            /* OF device node */
-        struct semaphore        mutex;          /* Access mutex for use by i2c-keywest */
-        low_i2c_func_t          func;           /* Access function */
-        int                     is_open : 1;    /* Poor man's access control */
-        int                     mode;           /* Current mode */
-        int                     channel;        /* Current channel */
-        int                     num_channels;   /* Number of channels */
-        void __iomem *          base;           /* For keywest-i2c, base address */
-        int                     bsteps;         /* And register stepping */
-        int                     speed;          /* And speed */
-};
-
-static struct low_i2c_host      low_i2c_hosts[MAX_LOW_I2C_HOST];
-
-/* No locking is necessary on allocation, we are running way before
- * anything can race with us
- */
-static struct low_i2c_host *find_low_i2c_host(struct device_node *np)
-{
-        int i;
-
-        for (i = 0; i < MAX_LOW_I2C_HOST; i++)
-                if (low_i2c_hosts[i].np == np)
-                        return &low_i2c_hosts[i];
-        return NULL;
-}
-
-/*
- *
- * i2c-keywest implementation (UniNorth, U2, U3, Keylargo's)
- *
- */
-
-/*
- * Keywest i2c definitions borrowed from drivers/i2c/i2c-keywest.h,
- * should be moved somewhere in include/asm-ppc/
- */
-/* Register indices */
-typedef enum {
-        reg_mode = 0,
-        reg_control,
-        reg_status,
-        reg_isr,
-        reg_ier,
-        reg_addr,
-        reg_subaddr,
-        reg_data
-} reg_t;
-
-
-/* Mode register */
-#define KW_I2C_MODE_100KHZ      0x00
-#define KW_I2C_MODE_50KHZ       0x01
-#define KW_I2C_MODE_25KHZ       0x02
-#define KW_I2C_MODE_DUMB        0x00
-#define KW_I2C_MODE_STANDARD    0x04
-#define KW_I2C_MODE_STANDARDSUB 0x08
-#define KW_I2C_MODE_COMBINED    0x0C
-#define KW_I2C_MODE_MODE_MASK   0x0C
-#define KW_I2C_MODE_CHAN_MASK   0xF0
-
-/* Control register */
-#define KW_I2C_CTL_AAK          0x01
-#define KW_I2C_CTL_XADDR        0x02
-#define KW_I2C_CTL_STOP         0x04
-#define KW_I2C_CTL_START        0x08
-
-/* Status register */
-#define KW_I2C_STAT_BUSY        0x01
-#define KW_I2C_STAT_LAST_AAK    0x02
-#define KW_I2C_STAT_LAST_RW     0x04
-#define KW_I2C_STAT_SDA         0x08
-#define KW_I2C_STAT_SCL         0x10
-
-/* IER & ISR registers */
-#define KW_I2C_IRQ_DATA         0x01
-#define KW_I2C_IRQ_ADDR         0x02
-#define KW_I2C_IRQ_STOP         0x04
-#define KW_I2C_IRQ_START        0x08
-#define KW_I2C_IRQ_MASK         0x0F
-
-/* State machine states */
-enum {
-        state_idle,
-        state_addr,
-        state_read,
-        state_write,
-        state_stop,
-        state_dead
-};
-
-#define WRONG_STATE(name) do {\
-                printk(KERN_DEBUG "KW: wrong state. Got %s, state: %s (isr: %02x)\n", \
-                       name, __kw_state_names[state], isr); \
-        } while(0)
-
-static const char *__kw_state_names[] = {
-        "state_idle",
-        "state_addr",
-        "state_read",
-        "state_write",
-        "state_stop",
-        "state_dead"
-};
-
-static inline u8 __kw_read_reg(struct low_i2c_host *host, reg_t reg)
-{
-        return in_8(host->base + (((unsigned)reg) << host->bsteps));
-}
-
-static inline void __kw_write_reg(struct low_i2c_host *host, reg_t reg, u8 val)
-{
-        out_8(host->base + (((unsigned)reg) << host->bsteps), val);
-        (void)__kw_read_reg(host, reg_subaddr);
-}
-
-#define kw_write_reg(reg, val)  __kw_write_reg(host, reg, val) 
-#define kw_read_reg(reg)        __kw_read_reg(host, reg) 
-
-
-/* Don't schedule, the g5 fan controller is too
- * timing sensitive
- */
-static u8 kw_wait_interrupt(struct low_i2c_host* host)
-{
-        int i;
-        u8 isr;
-        
-        for (i = 0; i < 200000; i++) {
-                isr = kw_read_reg(reg_isr) & KW_I2C_IRQ_MASK;
-                if (isr != 0)
-                        return isr;
-                udelay(1);
-        }
-        return isr;
-}
-
-static int kw_handle_interrupt(struct low_i2c_host *host, int state, int rw, int *rc, u8 **data, int *len, u8 isr)
-{
-        u8 ack;
-
-        if (isr == 0) {
-                if (state != state_stop) {
-                        DBG("KW: Timeout !\n");
-                        *rc = -EIO;
-                        goto stop;
-                }
-                if (state == state_stop) {
-                        ack = kw_read_reg(reg_status);
-                        if (!(ack & KW_I2C_STAT_BUSY)) {
-                                state = state_idle;
-                                kw_write_reg(reg_ier, 0x00);
-                        }
-                }
-                return state;
-        }
-
-        if (isr & KW_I2C_IRQ_ADDR) {
-                ack = kw_read_reg(reg_status);
-                if (state != state_addr) {
-                        kw_write_reg(reg_isr, KW_I2C_IRQ_ADDR);
-                        WRONG_STATE("KW_I2C_IRQ_ADDR"); 
-                        *rc = -EIO;
-                        goto stop;
-                }
-                if ((ack & KW_I2C_STAT_LAST_AAK) == 0) {                        
-                        *rc = -ENODEV;
-                        DBG("KW: NAK on address\n");
-                        return state_stop;                   
-                } else {
-                        if (rw) {
-                                state = state_read;
-                                if (*len > 1)
-                                        kw_write_reg(reg_control, KW_I2C_CTL_AAK);
-                        } else {
-                                state = state_write;
-                                kw_write_reg(reg_data, **data);
-                                (*data)++; (*len)--;
-                        }
-                }
-                kw_write_reg(reg_isr, KW_I2C_IRQ_ADDR);
-        }
-
-        if (isr & KW_I2C_IRQ_DATA) {
-                if (state == state_read) {
-                        **data = kw_read_reg(reg_data);
-                        (*data)++; (*len)--;
-                        kw_write_reg(reg_isr, KW_I2C_IRQ_DATA);
-                        if ((*len) == 0)
-                                state = state_stop;
-                        else if ((*len) == 1)
-                                kw_write_reg(reg_control, 0);
-                } else if (state == state_write) {
-                        ack = kw_read_reg(reg_status);
-                        if ((ack & KW_I2C_STAT_LAST_AAK) == 0) {
-                                DBG("KW: nack on data write\n");
-                                *rc = -EIO;
-                                goto stop;
-                        } else if (*len) {
-                                kw_write_reg(reg_data, **data);
-                                (*data)++; (*len)--;
-                        } else {
-                                kw_write_reg(reg_control, KW_I2C_CTL_STOP);
-                                state = state_stop;
-                                *rc = 0;
-                        }
-                        kw_write_reg(reg_isr, KW_I2C_IRQ_DATA);
-                } else {
-                        kw_write_reg(reg_isr, KW_I2C_IRQ_DATA);
-                        WRONG_STATE("KW_I2C_IRQ_DATA"); 
-                        if (state != state_stop) {
-                                *rc = -EIO;
-                                goto stop;
-                        }
-                }
-        }
-
-        if (isr & KW_I2C_IRQ_STOP) {
-                kw_write_reg(reg_isr, KW_I2C_IRQ_STOP);
-                if (state != state_stop) {
-                        WRONG_STATE("KW_I2C_IRQ_STOP");
-                        *rc = -EIO;
-                }
-                return state_idle;
-        }
-
-        if (isr & KW_I2C_IRQ_START)
-                kw_write_reg(reg_isr, KW_I2C_IRQ_START);
-
-        return state;
-
- stop:
-        kw_write_reg(reg_control, KW_I2C_CTL_STOP);     
-        return state_stop;
-}
-
-static int keywest_low_i2c_func(struct low_i2c_host *host, u8 addr, u8 subaddr, u8 *data, int len)
-{
-        u8 mode_reg = host->speed;
-        int state = state_addr;
-        int rc = 0;
-
-        /* Setup mode & subaddress if any */
-        switch(host->mode) {
-        case pmac_low_i2c_mode_dumb:
-                printk(KERN_ERR "low_i2c: Dumb mode not supported !\n");
-                return -EINVAL;
-        case pmac_low_i2c_mode_std:
-                mode_reg |= KW_I2C_MODE_STANDARD;
-                break;
-        case pmac_low_i2c_mode_stdsub:
-                mode_reg |= KW_I2C_MODE_STANDARDSUB;
-                kw_write_reg(reg_subaddr, subaddr);
-                break;
-        case pmac_low_i2c_mode_combined:
-                mode_reg |= KW_I2C_MODE_COMBINED;
-                kw_write_reg(reg_subaddr, subaddr);
-                break;
-        }
-
-        /* Setup channel & clear pending irqs */
-        kw_write_reg(reg_isr, kw_read_reg(reg_isr));
-        kw_write_reg(reg_mode, mode_reg | (host->channel << 4));
-        kw_write_reg(reg_status, 0);
-
-        /* Set up address and r/w bit */
-        kw_write_reg(reg_addr, addr);
-
-        /* Start sending address & disable interrupt*/
-        kw_write_reg(reg_ier, 0 /*KW_I2C_IRQ_MASK*/);
-        kw_write_reg(reg_control, KW_I2C_CTL_XADDR);
-
-        /* State machine, to turn into an interrupt handler */
-        while(state != state_idle) {
-                u8 isr = kw_wait_interrupt(host);
-                state = kw_handle_interrupt(host, state, addr & 1, &rc, &data, &len, isr);
-        }
-
-        return rc;
-}
-
-static void keywest_low_i2c_add(struct device_node *np)
-{
-        struct low_i2c_host     *host = find_low_i2c_host(NULL);
-        unsigned long           *psteps, *prate, steps, aoffset = 0;
-        struct device_node      *parent;
-
-        if (host == NULL) {
-                printk(KERN_ERR "low_i2c: Can't allocate host for %s\n",
-                       np->full_name);
-                return;
-        }
-        memset(host, 0, sizeof(*host));
-
-        init_MUTEX(&host->mutex);
-        host->np = of_node_get(np);     
-        psteps = (unsigned long *)get_property(np, "AAPL,address-step", NULL);
-        steps = psteps ? (*psteps) : 0x10;
-        for (host->bsteps = 0; (steps & 0x01) == 0; host->bsteps++)
-                steps >>= 1;
-        parent = of_get_parent(np);
-        host->num_channels = 1;
-        if (parent && parent->name[0] == 'u') {
-                host->num_channels = 2;
-                aoffset = 3;
-        }
-        /* Select interface rate */
-        host->speed = KW_I2C_MODE_100KHZ;
-        prate = (unsigned long *)get_property(np, "AAPL,i2c-rate", NULL);
-        if (prate) switch(*prate) {
-        case 100:
-                host->speed = KW_I2C_MODE_100KHZ;
-                break;
-        case 50:
-                host->speed = KW_I2C_MODE_50KHZ;
-                break;
-        case 25:
-                host->speed = KW_I2C_MODE_25KHZ;
-                break;
-        }       
-        host->mode = pmac_low_i2c_mode_std;
-        host->base = ioremap(np->addrs[0].address + aoffset,
-                                                np->addrs[0].size);
-        host->func = keywest_low_i2c_func;
-}
-
-/*
- *
- * PMU implementation
- *
- */
-
-
-#ifdef CONFIG_ADB_PMU
-
-static int pmu_low_i2c_func(struct low_i2c_host *host, u8 addr, u8 sub, u8 *data, int len)
-{
-        // TODO
-        return -ENODEV;
-}
-
-static void pmu_low_i2c_add(struct device_node *np)
-{
-        struct low_i2c_host     *host = find_low_i2c_host(NULL);
-
-        if (host == NULL) {
-                printk(KERN_ERR "low_i2c: Can't allocate host for %s\n",
-                       np->full_name);
-                return;
-        }
-        memset(host, 0, sizeof(*host));
-
-        init_MUTEX(&host->mutex);
-        host->np = of_node_get(np);     
-        host->num_channels = 3;
-        host->mode = pmac_low_i2c_mode_std;
-        host->func = pmu_low_i2c_func;
-}
-
-#endif /* CONFIG_ADB_PMU */
-
-void __init pmac_init_low_i2c(void)
-{
-        struct device_node *np;
-
-        /* Probe keywest-i2c busses */
-        np = of_find_compatible_node(NULL, "i2c", "keywest-i2c");
-        while(np) {
-                keywest_low_i2c_add(np);
-                np = of_find_compatible_node(np, "i2c", "keywest-i2c");
-        }
-
-#ifdef CONFIG_ADB_PMU
-        /* Probe PMU busses */
-        np = of_find_node_by_name(NULL, "via-pmu");
-        if (np)
-                pmu_low_i2c_add(np);
-#endif /* CONFIG_ADB_PMU */
-
-        /* TODO: Add CUDA support as well */
-}
-
-int pmac_low_i2c_lock(struct device_node *np)
-{
-        struct low_i2c_host *host = find_low_i2c_host(np);
-
-        if (!host)
-                return -ENODEV;
-        down(&host->mutex);
-        return 0;
-}
-EXPORT_SYMBOL(pmac_low_i2c_lock);
-
-int pmac_low_i2c_unlock(struct device_node *np)
-{
-        struct low_i2c_host *host = find_low_i2c_host(np);
-
-        if (!host)
-                return -ENODEV;
-        up(&host->mutex);
-        return 0;
-}
-EXPORT_SYMBOL(pmac_low_i2c_unlock);
-
-
-int pmac_low_i2c_open(struct device_node *np, int channel)
-{
-        struct low_i2c_host *host = find_low_i2c_host(np);
-
-        if (!host)
-                return -ENODEV;
-
-        if (channel >= host->num_channels)
-                return -EINVAL;
-
-        down(&host->mutex);
-        host->is_open = 1;
-        host->channel = channel;
-
-        return 0;
-}
-EXPORT_SYMBOL(pmac_low_i2c_open);
-
-int pmac_low_i2c_close(struct device_node *np)
-{
-        struct low_i2c_host *host = find_low_i2c_host(np);
-
-        if (!host)
-                return -ENODEV;
-
-        host->is_open = 0;
-        up(&host->mutex);
-
-        return 0;
-}
-EXPORT_SYMBOL(pmac_low_i2c_close);
-
-int pmac_low_i2c_setmode(struct device_node *np, int mode)
-{
-        struct low_i2c_host *host = find_low_i2c_host(np);
-
-        if (!host)
-                return -ENODEV;
-        WARN_ON(!host->is_open);
-        host->mode = mode;
-
-        return 0;
-}
-EXPORT_SYMBOL(pmac_low_i2c_setmode);
-
-int pmac_low_i2c_xfer(struct device_node *np, u8 addrdir, u8 subaddr, u8 *data, int len)
-{
-        struct low_i2c_host *host = find_low_i2c_host(np);
-
-        if (!host)
-                return -ENODEV;
-        WARN_ON(!host->is_open);
-
-        return host->func(host, addrdir, subaddr, data, len);
-}
-EXPORT_SYMBOL(pmac_low_i2c_xfer);
-
diff --git a/arch/ppc/platforms/pmac_nvram.c b/arch/ppc/platforms/pmac_nvram.c
deleted file mode 100644
index 8c9b008c7226..000000000000
--- a/arch/ppc/platforms/pmac_nvram.c
+++ /dev/null
@@ -1,584 +0,0 @@
-/*
- *  arch/ppc/platforms/pmac_nvram.c
- *
- *  Copyright (C) 2002 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.
- *
- *  Todo: - add support for the OF persistent properties
- */
-#include <linux/config.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/stddef.h>
-#include <linux/string.h>
-#include <linux/nvram.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/delay.h>
-#include <linux/errno.h>
-#include <linux/adb.h>
-#include <linux/pmu.h>
-#include <linux/bootmem.h>
-#include <linux/completion.h>
-#include <linux/spinlock.h>
-#include <asm/sections.h>
-#include <asm/io.h>
-#include <asm/system.h>
-#include <asm/prom.h>
-#include <asm/machdep.h>
-#include <asm/nvram.h>
-
-#define DEBUG
-
-#ifdef DEBUG
-#define DBG(x...) printk(x)
-#else
-#define DBG(x...)
-#endif
-
-#define NVRAM_SIZE              0x2000  /* 8kB of non-volatile RAM */
-
-#define CORE99_SIGNATURE        0x5a
-#define CORE99_ADLER_START      0x14
-
-/* On Core99, nvram is either a sharp, a micron or an AMD flash */
-#define SM_FLASH_STATUS_DONE    0x80
-#define SM_FLASH_STATUS_ERR             0x38
-#define SM_FLASH_CMD_ERASE_CONFIRM      0xd0
-#define SM_FLASH_CMD_ERASE_SETUP        0x20
-#define SM_FLASH_CMD_RESET              0xff
-#define SM_FLASH_CMD_WRITE_SETUP        0x40
-#define SM_FLASH_CMD_CLEAR_STATUS       0x50
-#define SM_FLASH_CMD_READ_STATUS        0x70
-
-/* CHRP NVRAM header */
-struct chrp_header {
-  u8            signature;
-  u8            cksum;
-  u16           len;
-  char          name[12];
-  u8            data[0];
-};
-
-struct core99_header {
-  struct chrp_header    hdr;
-  u32                   adler;
-  u32                   generation;
-  u32                   reserved[2];
-};
-
-/*
- * Read and write the non-volatile RAM on PowerMacs and CHRP machines.
- */
-static int nvram_naddrs;
-static volatile unsigned char *nvram_addr;
-static volatile unsigned char *nvram_data;
-static int nvram_mult, is_core_99;
-static int core99_bank = 0;
-static int nvram_partitions[3];
-static DEFINE_SPINLOCK(nv_lock);
-
-extern int pmac_newworld;
-extern int system_running;
-
-static int (*core99_write_bank)(int bank, u8* datas);
-static int (*core99_erase_bank)(int bank);
-
-static char *nvram_image;
-
-
-static unsigned char core99_nvram_read_byte(int addr)
-{
-        if (nvram_image == NULL)
-                return 0xff;
-        return nvram_image[addr];
-}
-
-static void core99_nvram_write_byte(int addr, unsigned char val)
-{
-        if (nvram_image == NULL)
-                return;
-        nvram_image[addr] = val;
-}
-
-
-static unsigned char direct_nvram_read_byte(int addr)
-{
-        return in_8(&nvram_data[(addr & (NVRAM_SIZE - 1)) * nvram_mult]);
-}
-
-static void direct_nvram_write_byte(int addr, unsigned char val)
-{
-        out_8(&nvram_data[(addr & (NVRAM_SIZE - 1)) * nvram_mult], val);
-}
-
-
-static unsigned char indirect_nvram_read_byte(int addr)
-{
-        unsigned char val;
-        unsigned long flags;
-
-        spin_lock_irqsave(&nv_lock, flags);
-        out_8(nvram_addr, addr >> 5);
-        val = in_8(&nvram_data[(addr & 0x1f) << 4]);
-        spin_unlock_irqrestore(&nv_lock, flags);
-
-        return val;
-}
-
-static void indirect_nvram_write_byte(int addr, unsigned char val)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&nv_lock, flags);
-        out_8(nvram_addr, addr >> 5);
-        out_8(&nvram_data[(addr & 0x1f) << 4], val);
-        spin_unlock_irqrestore(&nv_lock, flags);
-}
-
-
-#ifdef CONFIG_ADB_PMU
-
-static void pmu_nvram_complete(struct adb_request *req)
-{
-        if (req->arg)
-                complete((struct completion *)req->arg);
-}
-
-static unsigned char pmu_nvram_read_byte(int addr)
-{
-        struct adb_request req;
-        DECLARE_COMPLETION(req_complete); 
-        
-        req.arg = system_state == SYSTEM_RUNNING ? &req_complete : NULL;
-        if (pmu_request(&req, pmu_nvram_complete, 3, PMU_READ_NVRAM,
-                        (addr >> 8) & 0xff, addr & 0xff))
-                return 0xff;
-        if (system_state == SYSTEM_RUNNING)
-                wait_for_completion(&req_complete);
-        while (!req.complete)
-                pmu_poll();
-        return req.reply[0];
-}
-
-static void pmu_nvram_write_byte(int addr, unsigned char val)
-{
-        struct adb_request req;
-        DECLARE_COMPLETION(req_complete); 
-        
-        req.arg = system_state == SYSTEM_RUNNING ? &req_complete : NULL;
-        if (pmu_request(&req, pmu_nvram_complete, 4, PMU_WRITE_NVRAM,
-                        (addr >> 8) & 0xff, addr & 0xff, val))
-                return;
-        if (system_state == SYSTEM_RUNNING)
-                wait_for_completion(&req_complete);
-        while (!req.complete)
-                pmu_poll();
-}
-
-#endif /* CONFIG_ADB_PMU */
-
-
-static u8 chrp_checksum(struct chrp_header* hdr)
-{
-        u8 *ptr;
-        u16 sum = hdr->signature;
-        for (ptr = (u8 *)&hdr->len; ptr < hdr->data; ptr++)
-                sum += *ptr;
-        while (sum > 0xFF)
-                sum = (sum & 0xFF) + (sum>>8);
-        return sum;
-}
-
-static u32 core99_calc_adler(u8 *buffer)
-{
-        int cnt;
-        u32 low, high;
-
-        buffer += CORE99_ADLER_START;
-        low = 1;
-        high = 0;
-        for (cnt=0; cnt<(NVRAM_SIZE-CORE99_ADLER_START); cnt++) {
-                if ((cnt % 5000) == 0) {
-                        high  %= 65521UL;
-                        high %= 65521UL;
-                }
-                low += buffer[cnt];
-                high += low;
-        }
-        low  %= 65521UL;
-        high %= 65521UL;
-
-        return (high << 16) | low;
-}
-
-static u32 core99_check(u8* datas)
-{
-        struct core99_header* hdr99 = (struct core99_header*)datas;
-
-        if (hdr99->hdr.signature != CORE99_SIGNATURE) {
-                DBG("Invalid signature\n");
-                return 0;
-        }
-        if (hdr99->hdr.cksum != chrp_checksum(&hdr99->hdr)) {
-                DBG("Invalid checksum\n");
-                return 0;
-        }
-        if (hdr99->adler != core99_calc_adler(datas)) {
-                DBG("Invalid adler\n");
-                return 0;
-        }
-        return hdr99->generation;
-}
-
-static int sm_erase_bank(int bank)
-{
-        int stat, i;
-        unsigned long timeout;
-
-        u8* base = (u8 *)nvram_data + core99_bank*NVRAM_SIZE;
-
-        DBG("nvram: Sharp/Micron Erasing bank %d...\n", bank);
-
-        out_8(base, SM_FLASH_CMD_ERASE_SETUP);
-        out_8(base, SM_FLASH_CMD_ERASE_CONFIRM);
-        timeout = 0;
-        do {
-                if (++timeout > 1000000) {
-                        printk(KERN_ERR "nvram: Sharp/Miron flash erase timeout !\n");
-                        break;
-                }
-                out_8(base, SM_FLASH_CMD_READ_STATUS);
-                stat = in_8(base);
-        } while (!(stat & SM_FLASH_STATUS_DONE));
-
-        out_8(base, SM_FLASH_CMD_CLEAR_STATUS);
-        out_8(base, SM_FLASH_CMD_RESET);
-
-        for (i=0; i<NVRAM_SIZE; i++)
-                if (base[i] != 0xff) {
-                        printk(KERN_ERR "nvram: Sharp/Micron flash erase failed !\n");
-                        return -ENXIO;
-                }
-        return 0;
-}
-
-static int sm_write_bank(int bank, u8* datas)
-{
-        int i, stat = 0;
-        unsigned long timeout;
-
-        u8* base = (u8 *)nvram_data + core99_bank*NVRAM_SIZE;
-
-        DBG("nvram: Sharp/Micron Writing bank %d...\n", bank);
-
-        for (i=0; i<NVRAM_SIZE; i++) {
-                out_8(base+i, SM_FLASH_CMD_WRITE_SETUP);
-                udelay(1);
-                out_8(base+i, datas[i]);
-                timeout = 0;
-                do {
-                        if (++timeout > 1000000) {
-                                printk(KERN_ERR "nvram: Sharp/Micron flash write timeout !\n");
-                                break;
-                        }
-                        out_8(base, SM_FLASH_CMD_READ_STATUS);
-                        stat = in_8(base);
-                } while (!(stat & SM_FLASH_STATUS_DONE));
-                if (!(stat & SM_FLASH_STATUS_DONE))
-                        break;
-        }
-        out_8(base, SM_FLASH_CMD_CLEAR_STATUS);
-        out_8(base, SM_FLASH_CMD_RESET);
-        for (i=0; i<NVRAM_SIZE; i++)
-                if (base[i] != datas[i]) {
-                        printk(KERN_ERR "nvram: Sharp/Micron flash write failed !\n");
-                        return -ENXIO;
-                }
-        return 0;
-}
-
-static int amd_erase_bank(int bank)
-{
-        int i, stat = 0;
-        unsigned long timeout;
-
-        u8* base = (u8 *)nvram_data + core99_bank*NVRAM_SIZE;
-
-        DBG("nvram: AMD Erasing bank %d...\n", bank);
-
-        /* Unlock 1 */
-        out_8(base+0x555, 0xaa);
-        udelay(1);
-        /* Unlock 2 */
-        out_8(base+0x2aa, 0x55);
-        udelay(1);
-
-        /* Sector-Erase */
-        out_8(base+0x555, 0x80);
-        udelay(1);
-        out_8(base+0x555, 0xaa);
-        udelay(1);
-        out_8(base+0x2aa, 0x55);
-        udelay(1);
-        out_8(base, 0x30);
-        udelay(1);
-
-        timeout = 0;
-        do {
-                if (++timeout > 1000000) {
-                        printk(KERN_ERR "nvram: AMD flash erase timeout !\n");
-                        break;
-                }
-                stat = in_8(base) ^ in_8(base);
-        } while (stat != 0);
-        
-        /* Reset */
-        out_8(base, 0xf0);
-        udelay(1);
-        
-        for (i=0; i<NVRAM_SIZE; i++)
-                if (base[i] != 0xff) {
-                        printk(KERN_ERR "nvram: AMD flash erase failed !\n");
-                        return -ENXIO;
-                }
-        return 0;
-}
-
-static int amd_write_bank(int bank, u8* datas)
-{
-        int i, stat = 0;
-        unsigned long timeout;
-
-        u8* base = (u8 *)nvram_data + core99_bank*NVRAM_SIZE;
-
-        DBG("nvram: AMD Writing bank %d...\n", bank);
-
-        for (i=0; i<NVRAM_SIZE; i++) {
-                /* Unlock 1 */
-                out_8(base+0x555, 0xaa);
-                udelay(1);
-                /* Unlock 2 */
-                out_8(base+0x2aa, 0x55);
-                udelay(1);
-
-                /* Write single word */
-                out_8(base+0x555, 0xa0);
-                udelay(1);
-                out_8(base+i, datas[i]);
-                
-                timeout = 0;
-                do {
-                        if (++timeout > 1000000) {
-                                printk(KERN_ERR "nvram: AMD flash write timeout !\n");
-                                break;
-                        }
-                        stat = in_8(base) ^ in_8(base);
-                } while (stat != 0);
-                if (stat != 0)
-                        break;
-        }
-
-        /* Reset */
-        out_8(base, 0xf0);
-        udelay(1);
-
-        for (i=0; i<NVRAM_SIZE; i++)
-                if (base[i] != datas[i]) {
-                        printk(KERN_ERR "nvram: AMD flash write failed !\n");
-                        return -ENXIO;
-                }
-        return 0;
-}
-
-static void __init lookup_partitions(void)
-{
-        u8 buffer[17];
-        int i, offset;
-        struct chrp_header* hdr;
-
-        if (pmac_newworld) {
-                nvram_partitions[pmac_nvram_OF] = -1;
-                nvram_partitions[pmac_nvram_XPRAM] = -1;
-                nvram_partitions[pmac_nvram_NR] = -1;
-                hdr = (struct chrp_header *)buffer;
-
-                offset = 0;
-                buffer[16] = 0;
-                do {
-                        for (i=0;i<16;i++)
-                                buffer[i] = nvram_read_byte(offset+i);
-                        if (!strcmp(hdr->name, "common"))
-                                nvram_partitions[pmac_nvram_OF] = offset + 0x10;
-                        if (!strcmp(hdr->name, "APL,MacOS75")) {
-                                nvram_partitions[pmac_nvram_XPRAM] = offset + 0x10;
-                                nvram_partitions[pmac_nvram_NR] = offset + 0x110;
-                        }
-                        offset += (hdr->len * 0x10);
-                } while(offset < NVRAM_SIZE);
-        } else {
-                nvram_partitions[pmac_nvram_OF] = 0x1800;
-                nvram_partitions[pmac_nvram_XPRAM] = 0x1300;
-                nvram_partitions[pmac_nvram_NR] = 0x1400;
-        }
-        DBG("nvram: OF partition at 0x%x\n", nvram_partitions[pmac_nvram_OF]);
-        DBG("nvram: XP partition at 0x%x\n", nvram_partitions[pmac_nvram_XPRAM]);
-        DBG("nvram: NR partition at 0x%x\n", nvram_partitions[pmac_nvram_NR]);
-}
-
-static void core99_nvram_sync(void)
-{
-        struct core99_header* hdr99;
-        unsigned long flags;
-
-        if (!is_core_99 || !nvram_data || !nvram_image)
-                return;
-
-        spin_lock_irqsave(&nv_lock, flags);
-        if (!memcmp(nvram_image, (u8*)nvram_data + core99_bank*NVRAM_SIZE,
-                NVRAM_SIZE))
-                goto bail;
-
-        DBG("Updating nvram...\n");
-
-        hdr99 = (struct core99_header*)nvram_image;
-        hdr99->generation++;
-        hdr99->hdr.signature = CORE99_SIGNATURE;
-        hdr99->hdr.cksum = chrp_checksum(&hdr99->hdr);
-        hdr99->adler = core99_calc_adler(nvram_image);
-        core99_bank = core99_bank ? 0 : 1;
-        if (core99_erase_bank)
-                if (core99_erase_bank(core99_bank)) {
-                        printk("nvram: Error erasing bank %d\n", core99_bank);
-                        goto bail;
-                }
-        if (core99_write_bank)
-                if (core99_write_bank(core99_bank, nvram_image))
-                        printk("nvram: Error writing bank %d\n", core99_bank);
- bail:
-        spin_unlock_irqrestore(&nv_lock, flags);
-
-#ifdef DEBUG
-        mdelay(2000);
-#endif
-}
-
-void __init pmac_nvram_init(void)
-{
-        struct device_node *dp;
-
-        nvram_naddrs = 0;
-
-        dp = find_devices("nvram");
-        if (dp == NULL) {
-                printk(KERN_ERR "Can't find NVRAM device\n");
-                return;
-        }
-        nvram_naddrs = dp->n_addrs;
-        is_core_99 = device_is_compatible(dp, "nvram,flash");
-        if (is_core_99) {
-                int i;
-                u32 gen_bank0, gen_bank1;
-
-                if (nvram_naddrs < 1) {
-                        printk(KERN_ERR "nvram: no address\n");
-                        return;
-                }
-                nvram_image = alloc_bootmem(NVRAM_SIZE);
-                if (nvram_image == NULL) {
-                        printk(KERN_ERR "nvram: can't allocate ram image\n");
-                        return;
-                }
-                nvram_data = ioremap(dp->addrs[0].address, NVRAM_SIZE*2);
-                nvram_naddrs = 1; /* Make sure we get the correct case */
-
-                DBG("nvram: Checking bank 0...\n");
-
-                gen_bank0 = core99_check((u8 *)nvram_data);
-                gen_bank1 = core99_check((u8 *)nvram_data + NVRAM_SIZE);
-                core99_bank = (gen_bank0 < gen_bank1) ? 1 : 0;
-
-                DBG("nvram: gen0=%d, gen1=%d\n", gen_bank0, gen_bank1);
-                DBG("nvram: Active bank is: %d\n", core99_bank);
-
-                for (i=0; i<NVRAM_SIZE; i++)
-                        nvram_image[i] = nvram_data[i + core99_bank*NVRAM_SIZE];
-
-                ppc_md.nvram_read_val   = core99_nvram_read_byte;
-                ppc_md.nvram_write_val  = core99_nvram_write_byte;
-                ppc_md.nvram_sync       = core99_nvram_sync;
-                /* 
-                 * Maybe we could be smarter here though making an exclusive list
-                 * of known flash chips is a bit nasty as older OF didn't provide us
-                 * with a useful "compatible" entry. A solution would be to really
-                 * identify the chip using flash id commands and base ourselves on
-                 * a list of known chips IDs
-                 */
-                if (device_is_compatible(dp, "amd-0137")) {
-                        core99_erase_bank = amd_erase_bank;
-                        core99_write_bank = amd_write_bank;
-                } else {
-                        core99_erase_bank = sm_erase_bank;
-                        core99_write_bank = sm_write_bank;
-                }
-        } else if (_machine == _MACH_chrp && nvram_naddrs == 1) {
-                nvram_data = ioremap(dp->addrs[0].address + isa_mem_base,
-                                     dp->addrs[0].size);
-                nvram_mult = 1;
-                ppc_md.nvram_read_val   = direct_nvram_read_byte;
-                ppc_md.nvram_write_val  = direct_nvram_write_byte;
-        } else if (nvram_naddrs == 1) {
-                nvram_data = ioremap(dp->addrs[0].address, dp->addrs[0].size);
-                nvram_mult = (dp->addrs[0].size + NVRAM_SIZE - 1) / NVRAM_SIZE;
-                ppc_md.nvram_read_val   = direct_nvram_read_byte;
-                ppc_md.nvram_write_val  = direct_nvram_write_byte;
-        } else if (nvram_naddrs == 2) {
-                nvram_addr = ioremap(dp->addrs[0].address, dp->addrs[0].size);
-                nvram_data = ioremap(dp->addrs[1].address, dp->addrs[1].size);
-                ppc_md.nvram_read_val   = indirect_nvram_read_byte;
-                ppc_md.nvram_write_val  = indirect_nvram_write_byte;
-        } else if (nvram_naddrs == 0 && sys_ctrler == SYS_CTRLER_PMU) {
-#ifdef CONFIG_ADB_PMU
-                nvram_naddrs = -1;
-                ppc_md.nvram_read_val   = pmu_nvram_read_byte;
-                ppc_md.nvram_write_val  = pmu_nvram_write_byte;
-#endif /* CONFIG_ADB_PMU */
-        } else {
-                printk(KERN_ERR "Don't know how to access NVRAM with %d addresses\n",
-                       nvram_naddrs);
-        }
-        lookup_partitions();
-}
-
-int pmac_get_partition(int partition)
-{
-        return nvram_partitions[partition];
-}
-
-u8 pmac_xpram_read(int xpaddr)
-{
-        int offset = nvram_partitions[pmac_nvram_XPRAM];
-
-        if (offset < 0)
-                return 0xff;
-
-        return ppc_md.nvram_read_val(xpaddr + offset);
-}
-
-void pmac_xpram_write(int xpaddr, u8 data)
-{
-        int offset = nvram_partitions[pmac_nvram_XPRAM];
-
-        if (offset < 0)
-                return;
-
-        ppc_md.nvram_write_val(xpaddr + offset, data);
-}
-
-EXPORT_SYMBOL(pmac_get_partition);
-EXPORT_SYMBOL(pmac_xpram_read);
-EXPORT_SYMBOL(pmac_xpram_write);
diff --git a/arch/ppc/platforms/pmac_pci.c b/arch/ppc/platforms/pmac_pci.c
deleted file mode 100644
index 786295b6ddd0..000000000000
--- a/arch/ppc/platforms/pmac_pci.c
+++ /dev/null
@@ -1,1124 +0,0 @@
-/*
- * Support for PCI bridges found on Power Macintoshes.
- * At present the "bandit" and "chaos" bridges are supported.
- * Fortunately you access configuration space in the same
- * way with either bridge.
- *
- * Copyright (C) 1997 Paul Mackerras (paulus@cs.anu.edu.au)
- *
- * 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 <linux/kernel.h>
-#include <linux/pci.h>
-#include <linux/delay.h>
-#include <linux/string.h>
-#include <linux/init.h>
-
-#include <asm/sections.h>
-#include <asm/io.h>
-#include <asm/prom.h>
-#include <asm/pci-bridge.h>
-#include <asm/machdep.h>
-#include <asm/pmac_feature.h>
-
-#undef DEBUG
-
-#ifdef DEBUG
-#ifdef CONFIG_XMON
-extern void xmon_printf(const char *fmt, ...);
-#define DBG(x...) xmon_printf(x)
-#else
-#define DBG(x...) printk(x)
-#endif
-#else
-#define DBG(x...)
-#endif
-
-static int add_bridge(struct device_node *dev);
-extern void pmac_check_ht_link(void);
-
-/* XXX Could be per-controller, but I don't think we risk anything by
- * assuming we won't have both UniNorth and Bandit */
-static int has_uninorth;
-#ifdef CONFIG_POWER4
-static struct pci_controller *u3_agp;
-#endif /* CONFIG_POWER4 */
-
-extern u8 pci_cache_line_size;
-extern int pcibios_assign_bus_offset;
-
-struct device_node *k2_skiplist[2];
-
-/*
- * Magic constants for enabling cache coherency in the bandit/PSX bridge.
- */
-#define BANDIT_DEVID_2  8
-#define BANDIT_REVID    3
-
-#define BANDIT_DEVNUM   11
-#define BANDIT_MAGIC    0x50
-#define BANDIT_COHERENT 0x40
-
-static int __init
-fixup_one_level_bus_range(struct device_node *node, int higher)
-{
-        for (; node != 0;node = node->sibling) {
-                int * bus_range;
-                unsigned int *class_code;
-                int len;
-
-                /* For PCI<->PCI bridges or CardBus bridges, we go down */
-                class_code = (unsigned int *) get_property(node, "class-code", NULL);
-                if (!class_code || ((*class_code >> 8) != PCI_CLASS_BRIDGE_PCI &&
-                        (*class_code >> 8) != PCI_CLASS_BRIDGE_CARDBUS))
-                        continue;
-                bus_range = (int *) get_property(node, "bus-range", &len);
-                if (bus_range != NULL && len > 2 * sizeof(int)) {
-                        if (bus_range[1] > higher)
-                                higher = bus_range[1];
-                }
-                higher = fixup_one_level_bus_range(node->child, higher);
-        }
-        return higher;
-}
-
-/* This routine fixes the "bus-range" property of all bridges in the
- * system since they tend to have their "last" member wrong on macs
- *
- * Note that the bus numbers manipulated here are OF bus numbers, they
- * are not Linux bus numbers.
- */
-static void __init
-fixup_bus_range(struct device_node *bridge)
-{
-        int * bus_range;
-        int len;
-
-        /* Lookup the "bus-range" property for the hose */
-        bus_range = (int *) get_property(bridge, "bus-range", &len);
-        if (bus_range == NULL || len < 2 * sizeof(int)) {
-                printk(KERN_WARNING "Can't get bus-range for %s\n",
-                               bridge->full_name);
-                return;
-        }
-        bus_range[1] = fixup_one_level_bus_range(bridge->child, bus_range[1]);
-}
-
-/*
- * Apple MacRISC (U3, UniNorth, Bandit, Chaos) PCI controllers.
- *
- * The "Bandit" version is present in all early PCI PowerMacs,
- * and up to the first ones using Grackle. Some machines may
- * have 2 bandit controllers (2 PCI busses).
- *
- * "Chaos" is used in some "Bandit"-type machines as a bridge
- * for the separate display bus. It is accessed the same
- * way as bandit, but cannot be probed for devices. It therefore
- * has its own config access functions.
- *
- * The "UniNorth" version is present in all Core99 machines
- * (iBook, G4, new IMacs, and all the recent Apple machines).
- * It contains 3 controllers in one ASIC.
- *
- * The U3 is the bridge used on G5 machines. It contains an
- * AGP bus which is dealt with the old UniNorth access routines
- * and a HyperTransport bus which uses its own set of access
- * functions.
- */
-
-#define MACRISC_CFA0(devfn, off)        \
-        ((1 << (unsigned long)PCI_SLOT(dev_fn)) \
-        | (((unsigned long)PCI_FUNC(dev_fn)) << 8) \
-        | (((unsigned long)(off)) & 0xFCUL))
-
-#define MACRISC_CFA1(bus, devfn, off)   \
-        ((((unsigned long)(bus)) << 16) \
-        |(((unsigned long)(devfn)) << 8) \
-        |(((unsigned long)(off)) & 0xFCUL) \
-        |1UL)
-
-static void volatile __iomem *
-macrisc_cfg_access(struct pci_controller* hose, u8 bus, u8 dev_fn, u8 offset)
-{
-        unsigned int caddr;
-
-        if (bus == hose->first_busno) {
-                if (dev_fn < (11 << 3))
-                        return NULL;
-                caddr = MACRISC_CFA0(dev_fn, offset);
-        } else
-                caddr = MACRISC_CFA1(bus, dev_fn, offset);
-
-        /* Uninorth will return garbage if we don't read back the value ! */
-        do {
-                out_le32(hose->cfg_addr, caddr);
-        } while (in_le32(hose->cfg_addr) != caddr);
-
-        offset &= has_uninorth ? 0x07 : 0x03;
-        return hose->cfg_data + offset;
-}
-
-static int
-macrisc_read_config(struct pci_bus *bus, unsigned int devfn, int offset,
-                    int len, u32 *val)
-{
-        struct pci_controller *hose = bus->sysdata;
-        void volatile __iomem *addr;
-
-        addr = macrisc_cfg_access(hose, bus->number, devfn, offset);
-        if (!addr)
-                return PCIBIOS_DEVICE_NOT_FOUND;
-        /*
-         * Note: the caller has already checked that offset is
-         * suitably aligned and that len is 1, 2 or 4.
-         */
-        switch (len) {
-        case 1:
-                *val = in_8(addr);
-                break;
-        case 2:
-                *val = in_le16(addr);
-                break;
-        default:
-                *val = in_le32(addr);
-                break;
-        }
-        return PCIBIOS_SUCCESSFUL;
-}
-
-static int
-macrisc_write_config(struct pci_bus *bus, unsigned int devfn, int offset,
-                     int len, u32 val)
-{
-        struct pci_controller *hose = bus->sysdata;
-        void volatile __iomem *addr;
-
-        addr = macrisc_cfg_access(hose, bus->number, devfn, offset);
-        if (!addr)
-                return PCIBIOS_DEVICE_NOT_FOUND;
-        /*
-         * Note: the caller has already checked that offset is
-         * suitably aligned and that len is 1, 2 or 4.
-         */
-        switch (len) {
-        case 1:
-                out_8(addr, val);
-                (void) in_8(addr);
-                break;
-        case 2:
-                out_le16(addr, val);
-                (void) in_le16(addr);
-                break;
-        default:
-                out_le32(addr, val);
-                (void) in_le32(addr);
-                break;
-        }
-        return PCIBIOS_SUCCESSFUL;
-}
-
-static struct pci_ops macrisc_pci_ops =
-{
-        macrisc_read_config,
-        macrisc_write_config
-};
-
-/*
- * Verifiy that a specific (bus, dev_fn) exists on chaos
- */
-static int
-chaos_validate_dev(struct pci_bus *bus, int devfn, int offset)
-{
-        struct device_node *np;
-        u32 *vendor, *device;
-
-        np = pci_busdev_to_OF_node(bus, devfn);
-        if (np == NULL)
-                return PCIBIOS_DEVICE_NOT_FOUND;
-
-        vendor = (u32 *)get_property(np, "vendor-id", NULL);
-        device = (u32 *)get_property(np, "device-id", NULL);
-        if (vendor == NULL || device == NULL)
-                return PCIBIOS_DEVICE_NOT_FOUND;
-
-        if ((*vendor == 0x106b) && (*device == 3) && (offset >= 0x10)
-            && (offset != 0x14) && (offset != 0x18) && (offset <= 0x24))
-                return PCIBIOS_BAD_REGISTER_NUMBER;
-
-        return PCIBIOS_SUCCESSFUL;
-}
-
-static int
-chaos_read_config(struct pci_bus *bus, unsigned int devfn, int offset,
-                  int len, u32 *val)
-{
-        int result = chaos_validate_dev(bus, devfn, offset);
-        if (result == PCIBIOS_BAD_REGISTER_NUMBER)
-                *val = ~0U;
-        if (result != PCIBIOS_SUCCESSFUL)
-                return result;
-        return macrisc_read_config(bus, devfn, offset, len, val);
-}
-
-static int
-chaos_write_config(struct pci_bus *bus, unsigned int devfn, int offset,
-                   int len, u32 val)
-{
-        int result = chaos_validate_dev(bus, devfn, offset);
-        if (result != PCIBIOS_SUCCESSFUL)
-                return result;
-        return macrisc_write_config(bus, devfn, offset, len, val);
-}
-
-static struct pci_ops chaos_pci_ops =
-{
-        chaos_read_config,
-        chaos_write_config
-};
-
-#ifdef CONFIG_POWER4
-
-/*
- * These versions of U3 HyperTransport config space access ops do not
- * implement self-view of the HT host yet
- */
-
-#define U3_HT_CFA0(devfn, off)          \
-                ((((unsigned long)devfn) << 8) | offset)
-#define U3_HT_CFA1(bus, devfn, off)     \
-                (U3_HT_CFA0(devfn, off) \
-                + (((unsigned long)bus) << 16) \
-                + 0x01000000UL)
-
-static void volatile __iomem *
-u3_ht_cfg_access(struct pci_controller* hose, u8 bus, u8 devfn, u8 offset)
-{
-        if (bus == hose->first_busno) {
-                /* For now, we don't self probe U3 HT bridge */
-                if (PCI_FUNC(devfn) != 0 || PCI_SLOT(devfn) > 7 ||
-                    PCI_SLOT(devfn) < 1)
-                        return 0;
-                return hose->cfg_data + U3_HT_CFA0(devfn, offset);
-        } else
-                return hose->cfg_data + U3_HT_CFA1(bus, devfn, offset);
-}
-
-static int
-u3_ht_read_config(struct pci_bus *bus, unsigned int devfn, int offset,
-                    int len, u32 *val)
-{
-        struct pci_controller *hose = bus->sysdata;
-        void volatile __iomem *addr;
-        int i;
-
-        struct device_node *np = pci_busdev_to_OF_node(bus, devfn);
-        if (np == NULL)
-                return PCIBIOS_DEVICE_NOT_FOUND;
-
-        /*
-         * When a device in K2 is powered down, we die on config
-         * cycle accesses. Fix that here.
-         */
-        for (i=0; i<2; i++)
-                if (k2_skiplist[i] == np) {
-                        switch (len) {
-                        case 1:
-                                *val = 0xff; break;
-                        case 2:
-                                *val = 0xffff; break;
-                        default:
-                                *val = 0xfffffffful; break;
-                        }
-                        return PCIBIOS_SUCCESSFUL;
-                }
-            
-        addr = u3_ht_cfg_access(hose, bus->number, devfn, offset);
-        if (!addr)
-                return PCIBIOS_DEVICE_NOT_FOUND;
-        /*
-         * Note: the caller has already checked that offset is
-         * suitably aligned and that len is 1, 2 or 4.
-         */
-        switch (len) {
-        case 1:
-                *val = in_8(addr);
-                break;
-        case 2:
-                *val = in_le16(addr);
-                break;
-        default:
-                *val = in_le32(addr);
-                break;
-        }
-        return PCIBIOS_SUCCESSFUL;
-}
-
-static int
-u3_ht_write_config(struct pci_bus *bus, unsigned int devfn, int offset,
-                     int len, u32 val)
-{
-        struct pci_controller *hose = bus->sysdata;
-        void volatile __iomem *addr;
-        int i;
-
-        struct device_node *np = pci_busdev_to_OF_node(bus, devfn);
-        if (np == NULL)
-                return PCIBIOS_DEVICE_NOT_FOUND;
-        /*
-         * When a device in K2 is powered down, we die on config
-         * cycle accesses. Fix that here.
-         */
-        for (i=0; i<2; i++)
-                if (k2_skiplist[i] == np)
-                        return PCIBIOS_SUCCESSFUL;
-
-        addr = u3_ht_cfg_access(hose, bus->number, devfn, offset);
-        if (!addr)
-                return PCIBIOS_DEVICE_NOT_FOUND;
-        /*
-         * Note: the caller has already checked that offset is
-         * suitably aligned and that len is 1, 2 or 4.
-         */
-        switch (len) {
-        case 1:
-                out_8(addr, val);
-                (void) in_8(addr);
-                break;
-        case 2:
-                out_le16(addr, val);
-                (void) in_le16(addr);
-                break;
-        default:
-                out_le32(addr, val);
-                (void) in_le32(addr);
-                break;
-        }
-        return PCIBIOS_SUCCESSFUL;
-}
-
-static struct pci_ops u3_ht_pci_ops =
-{
-        u3_ht_read_config,
-        u3_ht_write_config
-};
-
-#endif /* CONFIG_POWER4 */
-
-/*
- * For a bandit bridge, turn on cache coherency if necessary.
- * N.B. we could clean this up using the hose ops directly.
- */
-static void __init
-init_bandit(struct pci_controller *bp)
-{
-        unsigned int vendev, magic;
-        int rev;
-
-        /* read the word at offset 0 in config space for device 11 */
-        out_le32(bp->cfg_addr, (1UL << BANDIT_DEVNUM) + PCI_VENDOR_ID);
-        udelay(2);
-        vendev = in_le32(bp->cfg_data);
-        if (vendev == (PCI_DEVICE_ID_APPLE_BANDIT << 16) +
-                        PCI_VENDOR_ID_APPLE) {
-                /* read the revision id */
-                out_le32(bp->cfg_addr,
-                         (1UL << BANDIT_DEVNUM) + PCI_REVISION_ID);
-                udelay(2);
-                rev = in_8(bp->cfg_data);
-                if (rev != BANDIT_REVID)
-                        printk(KERN_WARNING
-                               "Unknown revision %d for bandit\n", rev);
-        } else if (vendev != (BANDIT_DEVID_2 << 16) + PCI_VENDOR_ID_APPLE) {
-                printk(KERN_WARNING "bandit isn't? (%x)\n", vendev);
-                return;
-        }
-
-        /* read the word at offset 0x50 */
-        out_le32(bp->cfg_addr, (1UL << BANDIT_DEVNUM) + BANDIT_MAGIC);
-        udelay(2);
-        magic = in_le32(bp->cfg_data);
-        if ((magic & BANDIT_COHERENT) != 0)
-                return;
-        magic |= BANDIT_COHERENT;
-        udelay(2);
-        out_le32(bp->cfg_data, magic);
-        printk(KERN_INFO "Cache coherency enabled for bandit/PSX\n");
-}
-
-
-/*
- * Tweak the PCI-PCI bridge chip on the blue & white G3s.
- */
-static void __init
-init_p2pbridge(void)
-{
-        struct device_node *p2pbridge;
-        struct pci_controller* hose;
-        u8 bus, devfn;
-        u16 val;
-
-        /* XXX it would be better here to identify the specific
-           PCI-PCI bridge chip we have. */
-        if ((p2pbridge = find_devices("pci-bridge")) == 0
-            || p2pbridge->parent == NULL
-            || strcmp(p2pbridge->parent->name, "pci") != 0)
-                return;
-        if (pci_device_from_OF_node(p2pbridge, &bus, &devfn) < 0) {
-                DBG("Can't find PCI infos for PCI<->PCI bridge\n");
-                return;
-        }
-        /* Warning: At this point, we have not yet renumbered all busses.
-         * So we must use OF walking to find out hose
-         */
-        hose = pci_find_hose_for_OF_device(p2pbridge);
-        if (!hose) {
-                DBG("Can't find hose for PCI<->PCI bridge\n");
-                return;
-        }
-        if (early_read_config_word(hose, bus, devfn,
-                                   PCI_BRIDGE_CONTROL, &val) < 0) {
-                printk(KERN_ERR "init_p2pbridge: couldn't read bridge control\n");
-                return;
-        }
-        val &= ~PCI_BRIDGE_CTL_MASTER_ABORT;
-        early_write_config_word(hose, bus, devfn, PCI_BRIDGE_CONTROL, val);
-}
-
-/*
- * Some Apple desktop machines have a NEC PD720100A USB2 controller
- * on the motherboard. Open Firmware, on these, will disable the
- * EHCI part of it so it behaves like a pair of OHCI's. This fixup
- * code re-enables it ;)
- */
-static void __init
-fixup_nec_usb2(void)
-{
-        struct device_node *nec;
-
-        for (nec = NULL; (nec = of_find_node_by_name(nec, "usb")) != NULL;) {
-                struct pci_controller *hose;
-                u32 data, *prop;
-                u8 bus, devfn;
-                
-                prop = (u32 *)get_property(nec, "vendor-id", NULL);
-                if (prop == NULL)
-                        continue;
-                if (0x1033 != *prop)
-                        continue;
-                prop = (u32 *)get_property(nec, "device-id", NULL);
-                if (prop == NULL)
-                        continue;
-                if (0x0035 != *prop)
-                        continue;
-                prop = (u32 *)get_property(nec, "reg", NULL);
-                if (prop == NULL)
-                        continue;
-                devfn = (prop[0] >> 8) & 0xff;
-                bus = (prop[0] >> 16) & 0xff;
-                if (PCI_FUNC(devfn) != 0)
-                        continue;
-                hose = pci_find_hose_for_OF_device(nec);
-                if (!hose)
-                        continue;
-                early_read_config_dword(hose, bus, devfn, 0xe4, &data);
-                if (data & 1UL) {
-                        printk("Found NEC PD720100A USB2 chip with disabled EHCI, fixing up...\n");
-                        data &= ~1UL;
-                        early_write_config_dword(hose, bus, devfn, 0xe4, data);
-                        early_write_config_byte(hose, bus, devfn | 2, PCI_INTERRUPT_LINE,
-                                nec->intrs[0].line);
-                }
-        }
-}
-
-void __init
-pmac_find_bridges(void)
-{
-        struct device_node *np, *root;
-        struct device_node *ht = NULL;
-
-        root = of_find_node_by_path("/");
-        if (root == NULL) {
-                printk(KERN_CRIT "pmac_find_bridges: can't find root of device tree\n");
-                return;
-        }
-        for (np = NULL; (np = of_get_next_child(root, np)) != NULL;) {
-                if (np->name == NULL)
-                        continue;
-                if (strcmp(np->name, "bandit") == 0
-                    || strcmp(np->name, "chaos") == 0
-                    || strcmp(np->name, "pci") == 0) {
-                        if (add_bridge(np) == 0)
-                                of_node_get(np);
-                }
-                if (strcmp(np->name, "ht") == 0) {
-                        of_node_get(np);
-                        ht = np;
-                }
-        }
-        of_node_put(root);
-
-        /* Probe HT last as it relies on the agp resources to be already
-         * setup
-         */
-        if (ht && add_bridge(ht) != 0)
-                of_node_put(ht);
-
-        init_p2pbridge();
-        fixup_nec_usb2();
-        
-        /* We are still having some issues with the Xserve G4, enabling
-         * some offset between bus number and domains for now when we
-         * assign all busses should help for now
-         */
-        if (pci_assign_all_buses)
-                pcibios_assign_bus_offset = 0x10;
-
-#ifdef CONFIG_POWER4 
-        /* There is something wrong with DMA on U3/HT. I haven't figured out
-         * the details yet, but if I set the cache line size to 128 bytes like
-         * it should, I'm getting memory corruption caused by devices like
-         * sungem (even without the MWI bit set, but maybe sungem doesn't
-         * care). Right now, it appears that setting up a 64 bytes line size
-         * works properly, 64 bytes beeing the max transfer size of HT, I
-         * suppose this is related the way HT/PCI are hooked together. I still
-         * need to dive into more specs though to be really sure of what's
-         * going on. --BenH.
-         *
-         * Ok, apparently, it's just that HT can't do more than 64 bytes
-         * transactions. MWI seem to be meaningless there as well, it may
-         * be worth nop'ing out pci_set_mwi too though I haven't done that
-         * yet.
-         *
-         * Note that it's a bit different for whatever is in the AGP slot.
-         * For now, I don't care, but this can become a real issue, we
-         * should probably hook pci_set_mwi anyway to make sure it sets
-         * the real cache line size in there.
-         */
-        if (machine_is_compatible("MacRISC4"))
-                pci_cache_line_size = 16; /* 64 bytes */
-
-        pmac_check_ht_link();
-#endif /* CONFIG_POWER4 */
-}
-
-#define GRACKLE_CFA(b, d, o)    (0x80 | ((b) << 8) | ((d) << 16) \
-                                 | (((o) & ~3) << 24))
-
-#define GRACKLE_PICR1_STG               0x00000040
-#define GRACKLE_PICR1_LOOPSNOOP         0x00000010
-
-/* N.B. this is called before bridges is initialized, so we can't
-   use grackle_pcibios_{read,write}_config_dword. */
-static inline void grackle_set_stg(struct pci_controller* bp, int enable)
-{
-        unsigned int val;
-
-        out_be32(bp->cfg_addr, GRACKLE_CFA(0, 0, 0xa8));
-        val = in_le32(bp->cfg_data);
-        val = enable? (val | GRACKLE_PICR1_STG) :
-                (val & ~GRACKLE_PICR1_STG);
-        out_be32(bp->cfg_addr, GRACKLE_CFA(0, 0, 0xa8));
-        out_le32(bp->cfg_data, val);
-        (void)in_le32(bp->cfg_data);
-}
-
-static inline void grackle_set_loop_snoop(struct pci_controller *bp, int enable)
-{
-        unsigned int val;
-
-        out_be32(bp->cfg_addr, GRACKLE_CFA(0, 0, 0xa8));
-        val = in_le32(bp->cfg_data);
-        val = enable? (val | GRACKLE_PICR1_LOOPSNOOP) :
-                (val & ~GRACKLE_PICR1_LOOPSNOOP);
-        out_be32(bp->cfg_addr, GRACKLE_CFA(0, 0, 0xa8));
-        out_le32(bp->cfg_data, val);
-        (void)in_le32(bp->cfg_data);
-}
-
-static int __init
-setup_uninorth(struct pci_controller* hose, struct reg_property* addr)
-{
-        pci_assign_all_buses = 1;
-        has_uninorth = 1;
-        hose->ops = &macrisc_pci_ops;
-        hose->cfg_addr = ioremap(addr->address + 0x800000, 0x1000);
-        hose->cfg_data = ioremap(addr->address + 0xc00000, 0x1000);
-        /* We "know" that the bridge at f2000000 has the PCI slots. */
-        return addr->address == 0xf2000000;
-}
-
-static void __init
-setup_bandit(struct pci_controller* hose, struct reg_property* addr)
-{
-        hose->ops = &macrisc_pci_ops;
-        hose->cfg_addr = ioremap(addr->address + 0x800000, 0x1000);
-        hose->cfg_data = ioremap(addr->address + 0xc00000, 0x1000);
-        init_bandit(hose);
-}
-
-static void __init
-setup_chaos(struct pci_controller* hose, struct reg_property* addr)
-{
-        /* assume a `chaos' bridge */
-        hose->ops = &chaos_pci_ops;
-        hose->cfg_addr = ioremap(addr->address + 0x800000, 0x1000);
-        hose->cfg_data = ioremap(addr->address + 0xc00000, 0x1000);
-}
-
-#ifdef CONFIG_POWER4
-
-static void __init
-setup_u3_agp(struct pci_controller* hose, struct reg_property* addr)
-{
-        /* On G5, we move AGP up to high bus number so we don't need
-         * to reassign bus numbers for HT. If we ever have P2P bridges
-         * on AGP, we'll have to move pci_assign_all_buses to the
-         * pci_controller structure so we enable it for AGP and not for
-         * HT childs.
-         * We hard code the address because of the different size of
-         * the reg address cell, we shall fix that by killing struct
-         * reg_property and using some accessor functions instead
-         */
-        hose->first_busno = 0xf0;
-        hose->last_busno = 0xff;
-        has_uninorth = 1;
-        hose->ops = &macrisc_pci_ops;
-        hose->cfg_addr = ioremap(0xf0000000 + 0x800000, 0x1000);
-        hose->cfg_data = ioremap(0xf0000000 + 0xc00000, 0x1000);
-
-        u3_agp = hose;
-}
-
-static void __init
-setup_u3_ht(struct pci_controller* hose, struct reg_property *addr)
-{
-        struct device_node *np = (struct device_node *)hose->arch_data;
-        int i, cur;
-
-        hose->ops = &u3_ht_pci_ops;
-
-        /* We hard code the address because of the different size of
-         * the reg address cell, we shall fix that by killing struct
-         * reg_property and using some accessor functions instead
-         */
-        hose->cfg_data = ioremap(0xf2000000, 0x02000000);
-
-        /*
-         * /ht node doesn't expose a "ranges" property, so we "remove" regions that
-         * have been allocated to AGP. So far, this version of the code doesn't assign
-         * any of the 0xfxxxxxxx "fine" memory regions to /ht.
-         * We need to fix that sooner or later by either parsing all child "ranges"
-         * properties or figuring out the U3 address space decoding logic and
-         * then read its configuration register (if any).
-         */
-        hose->io_base_phys = 0xf4000000;
-        hose->io_base_virt = ioremap(hose->io_base_phys, 0x00400000);
-        isa_io_base = (unsigned long) hose->io_base_virt;
-        hose->io_resource.name = np->full_name;
-        hose->io_resource.start = 0;
-        hose->io_resource.end = 0x003fffff;
-        hose->io_resource.flags = IORESOURCE_IO;
-        hose->pci_mem_offset = 0;
-        hose->first_busno = 0;
-        hose->last_busno = 0xef;
-        hose->mem_resources[0].name = np->full_name;
-        hose->mem_resources[0].start = 0x80000000;
-        hose->mem_resources[0].end = 0xefffffff;
-        hose->mem_resources[0].flags = IORESOURCE_MEM;
-
-        if (u3_agp == NULL) {
-                DBG("U3 has no AGP, using full resource range\n");
-                return;
-        }
-
-        /* We "remove" the AGP resources from the resources allocated to HT, that
-         * is we create "holes". However, that code does assumptions that so far
-         * happen to be true (cross fingers...), typically that resources in the
-         * AGP node are properly ordered
-         */
-        cur = 0;
-        for (i=0; i<3; i++) {
-                struct resource *res = &u3_agp->mem_resources[i];
-                if (res->flags != IORESOURCE_MEM)
-                        continue;
-                /* We don't care about "fine" resources */
-                if (res->start >= 0xf0000000)
-                        continue;
-                /* Check if it's just a matter of "shrinking" us in one direction */
-                if (hose->mem_resources[cur].start == res->start) {
-                        DBG("U3/HT: shrink start of %d, %08lx -> %08lx\n",
-                            cur, hose->mem_resources[cur].start, res->end + 1);
-                        hose->mem_resources[cur].start = res->end + 1;
-                        continue;
-                }
-                if (hose->mem_resources[cur].end == res->end) {
-                        DBG("U3/HT: shrink end of %d, %08lx -> %08lx\n",
-                            cur, hose->mem_resources[cur].end, res->start - 1);
-                        hose->mem_resources[cur].end = res->start - 1;
-                        continue;
-                }
-                /* No, it's not the case, we need a hole */
-                if (cur == 2) {
-                        /* not enough resources to make a hole, we drop part of the range */
-                        printk(KERN_WARNING "Running out of resources for /ht host !\n");
-                        hose->mem_resources[cur].end = res->start - 1;
-                        continue;
-                }               
-                cur++;
-                DBG("U3/HT: hole, %d end at %08lx, %d start at %08lx\n",
-                    cur-1, res->start - 1, cur, res->end + 1);
-                hose->mem_resources[cur].name = np->full_name;
-                hose->mem_resources[cur].flags = IORESOURCE_MEM;
-                hose->mem_resources[cur].start = res->end + 1;
-                hose->mem_resources[cur].end = hose->mem_resources[cur-1].end;
-                hose->mem_resources[cur-1].end = res->start - 1;
-        }
-}
-
-#endif /* CONFIG_POWER4 */
-
-void __init
-setup_grackle(struct pci_controller *hose)
-{
-        setup_indirect_pci(hose, 0xfec00000, 0xfee00000);
-        if (machine_is_compatible("AAPL,PowerBook1998"))
-                grackle_set_loop_snoop(hose, 1);
-#if 0   /* Disabled for now, HW problems ??? */
-        grackle_set_stg(hose, 1);
-#endif
-}
-
-/*
- * We assume that if we have a G3 powermac, we have one bridge called
- * "pci" (a MPC106) and no bandit or chaos bridges, and contrariwise,
- * if we have one or more bandit or chaos bridges, we don't have a MPC106.
- */
-static int __init
-add_bridge(struct device_node *dev)
-{
-        int len;
-        struct pci_controller *hose;
-        struct reg_property *addr;
-        char* disp_name;
-        int *bus_range;
-        int primary = 1;
-
-        DBG("Adding PCI host bridge %s\n", dev->full_name);
-
-        addr = (struct reg_property *) get_property(dev, "reg", &len);
-        if (addr == NULL || len < sizeof(*addr)) {
-                printk(KERN_WARNING "Can't use %s: no address\n",
-                       dev->full_name);
-                return -ENODEV;
-        }
-        bus_range = (int *) get_property(dev, "bus-range", &len);
-        if (bus_range == NULL || len < 2 * sizeof(int)) {
-                printk(KERN_WARNING "Can't get bus-range for %s, assume bus 0\n",
-                               dev->full_name);
-        }
-
-        hose = pcibios_alloc_controller();
-        if (!hose)
-                return -ENOMEM;
-        hose->arch_data = dev;
-        hose->first_busno = bus_range ? bus_range[0] : 0;
-        hose->last_busno = bus_range ? bus_range[1] : 0xff;
-
-        disp_name = NULL;
-#ifdef CONFIG_POWER4
-        if (device_is_compatible(dev, "u3-agp")) {
-                setup_u3_agp(hose, addr);
-                disp_name = "U3-AGP";
-                primary = 0;
-        } else if (device_is_compatible(dev, "u3-ht")) {
-                setup_u3_ht(hose, addr);
-                disp_name = "U3-HT";
-                primary = 1;
-        } else
-#endif /* CONFIG_POWER4 */
-        if (device_is_compatible(dev, "uni-north")) {
-                primary = setup_uninorth(hose, addr);
-                disp_name = "UniNorth";
-        } else if (strcmp(dev->name, "pci") == 0) {
-                /* XXX assume this is a mpc106 (grackle) */
-                setup_grackle(hose);
-                disp_name = "Grackle (MPC106)";
-        } else if (strcmp(dev->name, "bandit") == 0) {
-                setup_bandit(hose, addr);
-                disp_name = "Bandit";
-        } else if (strcmp(dev->name, "chaos") == 0) {
-                setup_chaos(hose, addr);
-                disp_name = "Chaos";
-                primary = 0;
-        }
-        printk(KERN_INFO "Found %s PCI host bridge at 0x%08x. Firmware bus number: %d->%d\n",
-                disp_name, addr->address, hose->first_busno, hose->last_busno);
-        DBG(" ->Hose at 0x%p, cfg_addr=0x%p,cfg_data=0x%p\n",
-                hose, hose->cfg_addr, hose->cfg_data);
-
-        /* Interpret the "ranges" property */
-        /* This also maps the I/O region and sets isa_io/mem_base */
-        pci_process_bridge_OF_ranges(hose, dev, primary);
-
-        /* Fixup "bus-range" OF property */
-        fixup_bus_range(dev);
-
-        return 0;
-}
-
-static void __init
-pcibios_fixup_OF_interrupts(void)
-{
-        struct pci_dev* dev = NULL;
-
-        /*
-         * Open Firmware often doesn't initialize the
-         * PCI_INTERRUPT_LINE config register properly, so we
-         * should find the device node and apply the interrupt
-         * obtained from the OF device-tree
-         */
-        for_each_pci_dev(dev) {
-                struct device_node *node;
-                node = pci_device_to_OF_node(dev);
-                /* this is the node, see if it has interrupts */
-                if (node && node->n_intrs > 0)
-                        dev->irq = node->intrs[0].line;
-                pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
-        }
-}
-
-void __init
-pmac_pcibios_fixup(void)
-{
-        /* Fixup interrupts according to OF tree */
-        pcibios_fixup_OF_interrupts();
-}
-
-int
-pmac_pci_enable_device_hook(struct pci_dev *dev, int initial)
-{
-        struct device_node* node;
-        int updatecfg = 0;
-        int uninorth_child;
-
-        node = pci_device_to_OF_node(dev);
-
-        /* We don't want to enable USB controllers absent from the OF tree
-         * (iBook second controller)
-         */
-        if (dev->vendor == PCI_VENDOR_ID_APPLE
-            && (dev->class == ((PCI_CLASS_SERIAL_USB << 8) | 0x10))
-            && !node) {
-                printk(KERN_INFO "Apple USB OHCI %s disabled by firmware\n",
-                       pci_name(dev));
-                return -EINVAL;
-        }
-
-        if (!node)
-                return 0;
-
-        uninorth_child = node->parent &&
-                device_is_compatible(node->parent, "uni-north");
-        
-        /* Firewire & GMAC were disabled after PCI probe, the driver is
-         * claiming them, we must re-enable them now.
-         */
-        if (uninorth_child && !strcmp(node->name, "firewire") &&
-            (device_is_compatible(node, "pci106b,18") ||
-             device_is_compatible(node, "pci106b,30") ||
-             device_is_compatible(node, "pci11c1,5811"))) {
-                pmac_call_feature(PMAC_FTR_1394_CABLE_POWER, node, 0, 1);
-                pmac_call_feature(PMAC_FTR_1394_ENABLE, node, 0, 1);
-                updatecfg = 1;
-        }
-        if (uninorth_child && !strcmp(node->name, "ethernet") &&
-            device_is_compatible(node, "gmac")) {
-                pmac_call_feature(PMAC_FTR_GMAC_ENABLE, node, 0, 1);
-                updatecfg = 1;
-        }
-
-        if (updatecfg) {
-                u16 cmd;
-        
-                /*
-                 * Make sure PCI is correctly configured
-                 *
-                 * We use old pci_bios versions of the function since, by
-                 * default, gmac is not powered up, and so will be absent
-                 * from the kernel initial PCI lookup.
-                 *
-                 * Should be replaced by 2.4 new PCI mechanisms and really
-                 * register the device.
-                 */
-                pci_read_config_word(dev, PCI_COMMAND, &cmd);
-                cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER | PCI_COMMAND_INVALIDATE;
-                pci_write_config_word(dev, PCI_COMMAND, cmd);
-                pci_write_config_byte(dev, PCI_LATENCY_TIMER, 16);
-                pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, pci_cache_line_size);
-        }
-
-        return 0;
-}
-
-/* We power down some devices after they have been probed. They'll
- * be powered back on later on
- */
-void __init
-pmac_pcibios_after_init(void)
-{
-        struct device_node* nd;
-
-#ifdef CONFIG_BLK_DEV_IDE
-        struct pci_dev *dev = NULL;
-
-        /* OF fails to initialize IDE controllers on macs
-         * (and maybe other machines)
-         *
-         * Ideally, this should be moved to the IDE layer, but we need
-         * to check specifically with Andre Hedrick how to do it cleanly
-         * since the common IDE code seem to care about the fact that the
-         * BIOS may have disabled a controller.
-         *
-         * -- BenH
-         */
-        for_each_pci_dev(dev) {
-                if ((dev->class >> 16) == PCI_BASE_CLASS_STORAGE)
-                        pci_enable_device(dev);
-        }
-#endif /* CONFIG_BLK_DEV_IDE */
-
-        nd = find_devices("firewire");
-        while (nd) {
-                if (nd->parent && (device_is_compatible(nd, "pci106b,18") ||
-                                   device_is_compatible(nd, "pci106b,30") ||
-                                   device_is_compatible(nd, "pci11c1,5811"))
-                    && device_is_compatible(nd->parent, "uni-north")) {
-                        pmac_call_feature(PMAC_FTR_1394_ENABLE, nd, 0, 0);
-                        pmac_call_feature(PMAC_FTR_1394_CABLE_POWER, nd, 0, 0);
-                }
-                nd = nd->next;
-        }
-        nd = find_devices("ethernet");
-        while (nd) {
-                if (nd->parent && device_is_compatible(nd, "gmac")
-                    && device_is_compatible(nd->parent, "uni-north"))
-                        pmac_call_feature(PMAC_FTR_GMAC_ENABLE, nd, 0, 0);
-                nd = nd->next;
-        }
-}
-
-void pmac_pci_fixup_cardbus(struct pci_dev* dev)
-{
-        if (_machine != _MACH_Pmac)
-                return;
-        /*
-         * Fix the interrupt routing on the various cardbus bridges
-         * used on powerbooks
-         */
-        if (dev->vendor != PCI_VENDOR_ID_TI)
-                return;
-        if (dev->device == PCI_DEVICE_ID_TI_1130 ||
-            dev->device == PCI_DEVICE_ID_TI_1131) {
-                u8 val;
-                /* Enable PCI interrupt */
-                if (pci_read_config_byte(dev, 0x91, &val) == 0)
-                        pci_write_config_byte(dev, 0x91, val | 0x30);
-                /* Disable ISA interrupt mode */
-                if (pci_read_config_byte(dev, 0x92, &val) == 0)
-                        pci_write_config_byte(dev, 0x92, val & ~0x06);
-        }
-        if (dev->device == PCI_DEVICE_ID_TI_1210 ||
-            dev->device == PCI_DEVICE_ID_TI_1211 ||
-            dev->device == PCI_DEVICE_ID_TI_1410 ||
-            dev->device == PCI_DEVICE_ID_TI_1510) {
-                u8 val;
-                /* 0x8c == TI122X_IRQMUX, 2 says to route the INTA
-                   signal out the MFUNC0 pin */
-                if (pci_read_config_byte(dev, 0x8c, &val) == 0)
-                        pci_write_config_byte(dev, 0x8c, (val & ~0x0f) | 2);
-                /* Disable ISA interrupt mode */
-                if (pci_read_config_byte(dev, 0x92, &val) == 0)
-                        pci_write_config_byte(dev, 0x92, val & ~0x06);
-        }
-}
-
-DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_TI, PCI_ANY_ID, pmac_pci_fixup_cardbus);
-
-void pmac_pci_fixup_pciata(struct pci_dev* dev)
-{
-       u8 progif = 0;
-
-       /*
-        * On PowerMacs, we try to switch any PCI ATA controller to
-        * fully native mode
-        */
-        if (_machine != _MACH_Pmac)
-                return;
-        /* Some controllers don't have the class IDE */
-        if (dev->vendor == PCI_VENDOR_ID_PROMISE)
-                switch(dev->device) {
-                case PCI_DEVICE_ID_PROMISE_20246:
-                case PCI_DEVICE_ID_PROMISE_20262:
-                case PCI_DEVICE_ID_PROMISE_20263:
-                case PCI_DEVICE_ID_PROMISE_20265:
-                case PCI_DEVICE_ID_PROMISE_20267:
-                case PCI_DEVICE_ID_PROMISE_20268:
-                case PCI_DEVICE_ID_PROMISE_20269:
-                case PCI_DEVICE_ID_PROMISE_20270:
-                case PCI_DEVICE_ID_PROMISE_20271:
-                case PCI_DEVICE_ID_PROMISE_20275:
-                case PCI_DEVICE_ID_PROMISE_20276:
-                case PCI_DEVICE_ID_PROMISE_20277:
-                        goto good;
-                }
-        /* Others, check PCI class */
-        if ((dev->class >> 8) != PCI_CLASS_STORAGE_IDE)
-                return;
- good:
-        pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
-        if ((progif & 5) != 5) {
-                printk(KERN_INFO "Forcing PCI IDE into native mode: %s\n", pci_name(dev));
-                (void) pci_write_config_byte(dev, PCI_CLASS_PROG, progif|5);
-                if (pci_read_config_byte(dev, PCI_CLASS_PROG, &progif) ||
-                    (progif & 5) != 5)
-                        printk(KERN_ERR "Rewrite of PROGIF failed !\n");
-        }
-}
-DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, pmac_pci_fixup_pciata);
-
-
-/*
- * Disable second function on K2-SATA, it's broken
- * and disable IO BARs on first one
- */
-void pmac_pci_fixup_k2_sata(struct pci_dev* dev)
-{
-        int i;
-        u16 cmd;
-
-        if (PCI_FUNC(dev->devfn) > 0) {
-                pci_read_config_word(dev, PCI_COMMAND, &cmd);
-                cmd &= ~(PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
-                pci_write_config_word(dev, PCI_COMMAND, cmd);
-                for (i = 0; i < 6; i++) {
-                        dev->resource[i].start = dev->resource[i].end = 0;
-                        dev->resource[i].flags = 0;
-                        pci_write_config_dword(dev, PCI_BASE_ADDRESS_0 + 4 * i, 0);
-                }
-        } else {
-                pci_read_config_word(dev, PCI_COMMAND, &cmd);
-                cmd &= ~PCI_COMMAND_IO;
-                pci_write_config_word(dev, PCI_COMMAND, cmd);
-                for (i = 0; i < 5; i++) {
-                        dev->resource[i].start = dev->resource[i].end = 0;
-                        dev->resource[i].flags = 0;
-                        pci_write_config_dword(dev, PCI_BASE_ADDRESS_0 + 4 * i, 0);
-                }
-        }
-}
-DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SERVERWORKS, 0x0240, pmac_pci_fixup_k2_sata);
diff --git a/arch/ppc/platforms/pmac_pic.c b/arch/ppc/platforms/pmac_pic.c
deleted file mode 100644
index 4742bf609357..000000000000
--- a/arch/ppc/platforms/pmac_pic.c
+++ /dev/null
@@ -1,693 +0,0 @@
-/*
- *  Support for the interrupt controllers found on Power Macintosh,
- *  currently Apple's "Grand Central" interrupt controller in all
- *  it's incarnations. OpenPIC support used on newer machines is
- *  in a separate file
- *
- *  Copyright (C) 1997 Paul Mackerras (paulus@cs.anu.edu.au)
- *
- *  Maintained by 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.
- *
- */
-
-#include <linux/config.h>
-#include <linux/stddef.h>
-#include <linux/init.h>
-#include <linux/sched.h>
-#include <linux/signal.h>
-#include <linux/pci.h>
-#include <linux/interrupt.h>
-#include <linux/sysdev.h>
-#include <linux/adb.h>
-#include <linux/pmu.h>
-
-#include <asm/sections.h>
-#include <asm/io.h>
-#include <asm/smp.h>
-#include <asm/prom.h>
-#include <asm/pci-bridge.h>
-#include <asm/time.h>
-#include <asm/open_pic.h>
-#include <asm/xmon.h>
-#include <asm/pmac_feature.h>
-#include <asm/machdep.h>
-
-#include "pmac_pic.h"
-
-/*
- * XXX this should be in xmon.h, but putting it there means xmon.h
- * has to include <linux/interrupt.h> (to get irqreturn_t), which
- * causes all sorts of problems.  -- paulus
- */
-extern irqreturn_t xmon_irq(int, void *, struct pt_regs *);
-
-struct pmac_irq_hw {
-        unsigned int    event;
-        unsigned int    enable;
-        unsigned int    ack;
-        unsigned int    level;
-};
-
-/* Default addresses */
-static volatile struct pmac_irq_hw *pmac_irq_hw[4] = {
-        (struct pmac_irq_hw *) 0xf3000020,
-        (struct pmac_irq_hw *) 0xf3000010,
-        (struct pmac_irq_hw *) 0xf4000020,
-        (struct pmac_irq_hw *) 0xf4000010,
-};
-
-#define GC_LEVEL_MASK           0x3ff00000
-#define OHARE_LEVEL_MASK        0x1ff00000
-#define HEATHROW_LEVEL_MASK     0x1ff00000
-
-static int max_irqs;
-static int max_real_irqs;
-static u32 level_mask[4];
-
-static DEFINE_SPINLOCK(pmac_pic_lock);
-
-
-#define GATWICK_IRQ_POOL_SIZE        10
-static struct interrupt_info gatwick_int_pool[GATWICK_IRQ_POOL_SIZE];
-
-#define NR_MASK_WORDS   ((NR_IRQS + 31) / 32)
-static unsigned long ppc_lost_interrupts[NR_MASK_WORDS];
-
-/*
- * Mark an irq as "lost".  This is only used on the pmac
- * since it can lose interrupts (see pmac_set_irq_mask).
- * -- Cort
- */
-void
-__set_lost(unsigned long irq_nr, int nokick)
-{
-        if (!test_and_set_bit(irq_nr, ppc_lost_interrupts)) {
-                atomic_inc(&ppc_n_lost_interrupts);
-                if (!nokick)
-                        set_dec(1);
-        }
-}
-
-static void
-pmac_mask_and_ack_irq(unsigned int irq_nr)
-{
-        unsigned long bit = 1UL << (irq_nr & 0x1f);
-        int i = irq_nr >> 5;
-        unsigned long flags;
-
-        if ((unsigned)irq_nr >= max_irqs)
-                return;
-
-        clear_bit(irq_nr, ppc_cached_irq_mask);
-        if (test_and_clear_bit(irq_nr, ppc_lost_interrupts))
-                atomic_dec(&ppc_n_lost_interrupts);
-        spin_lock_irqsave(&pmac_pic_lock, flags);
-        out_le32(&pmac_irq_hw[i]->enable, ppc_cached_irq_mask[i]);
-        out_le32(&pmac_irq_hw[i]->ack, bit);
-        do {
-                /* make sure ack gets to controller before we enable
-                   interrupts */
-                mb();
-        } while((in_le32(&pmac_irq_hw[i]->enable) & bit)
-                != (ppc_cached_irq_mask[i] & bit));
-        spin_unlock_irqrestore(&pmac_pic_lock, flags);
-}
-
-static void pmac_set_irq_mask(unsigned int irq_nr, int nokicklost)
-{
-        unsigned long bit = 1UL << (irq_nr & 0x1f);
-        int i = irq_nr >> 5;
-        unsigned long flags;
-
-        if ((unsigned)irq_nr >= max_irqs)
-                return;
-
-        spin_lock_irqsave(&pmac_pic_lock, flags);
-        /* enable unmasked interrupts */
-        out_le32(&pmac_irq_hw[i]->enable, ppc_cached_irq_mask[i]);
-
-        do {
-                /* make sure mask gets to controller before we
-                   return to user */
-                mb();
-        } while((in_le32(&pmac_irq_hw[i]->enable) & bit)
-                != (ppc_cached_irq_mask[i] & bit));
-
-        /*
-         * Unfortunately, setting the bit in the enable register
-         * when the device interrupt is already on *doesn't* set
-         * the bit in the flag register or request another interrupt.
-         */
-        if (bit & ppc_cached_irq_mask[i] & in_le32(&pmac_irq_hw[i]->level))
-                __set_lost((ulong)irq_nr, nokicklost);
-        spin_unlock_irqrestore(&pmac_pic_lock, flags);
-}
-
-/* When an irq gets requested for the first client, if it's an
- * edge interrupt, we clear any previous one on the controller
- */
-static unsigned int pmac_startup_irq(unsigned int irq_nr)
-{
-        unsigned long bit = 1UL << (irq_nr & 0x1f);
-        int i = irq_nr >> 5;
-
-        if ((irq_desc[irq_nr].status & IRQ_LEVEL) == 0)
-                out_le32(&pmac_irq_hw[i]->ack, bit);
-        set_bit(irq_nr, ppc_cached_irq_mask);
-        pmac_set_irq_mask(irq_nr, 0);
-
-        return 0;
-}
-
-static void pmac_mask_irq(unsigned int irq_nr)
-{
-        clear_bit(irq_nr, ppc_cached_irq_mask);
-        pmac_set_irq_mask(irq_nr, 0);
-        mb();
-}
-
-static void pmac_unmask_irq(unsigned int irq_nr)
-{
-        set_bit(irq_nr, ppc_cached_irq_mask);
-        pmac_set_irq_mask(irq_nr, 0);
-}
-
-static void pmac_end_irq(unsigned int irq_nr)
-{
-        if (!(irq_desc[irq_nr].status & (IRQ_DISABLED|IRQ_INPROGRESS))
-            && irq_desc[irq_nr].action) {
-                set_bit(irq_nr, ppc_cached_irq_mask);
-                pmac_set_irq_mask(irq_nr, 1);
-        }
-}
-
-
-struct hw_interrupt_type pmac_pic = {
-        .typename       = " PMAC-PIC ",
-        .startup        = pmac_startup_irq,
-        .enable         = pmac_unmask_irq,
-        .disable        = pmac_mask_irq,
-        .ack            = pmac_mask_and_ack_irq,
-        .end            = pmac_end_irq,
-};
-
-struct hw_interrupt_type gatwick_pic = {
-        .typename       = " GATWICK  ",
-        .startup        = pmac_startup_irq,
-        .enable         = pmac_unmask_irq,
-        .disable        = pmac_mask_irq,
-        .ack            = pmac_mask_and_ack_irq,
-        .end            = pmac_end_irq,
-};
-
-static irqreturn_t gatwick_action(int cpl, void *dev_id, struct pt_regs *regs)
-{
-        int irq, bits;
-
-        for (irq = max_irqs; (irq -= 32) >= max_real_irqs; ) {
-                int i = irq >> 5;
-                bits = in_le32(&pmac_irq_hw[i]->event) | ppc_lost_interrupts[i];
-                /* We must read level interrupts from the level register */
-                bits |= (in_le32(&pmac_irq_hw[i]->level) & level_mask[i]);
-                bits &= ppc_cached_irq_mask[i];
-                if (bits == 0)
-                        continue;
-                irq += __ilog2(bits);
-                __do_IRQ(irq, regs);
-                return IRQ_HANDLED;
-        }
-        printk("gatwick irq not from gatwick pic\n");
-        return IRQ_NONE;
-}
-
-int
-pmac_get_irq(struct pt_regs *regs)
-{
-        int irq;
-        unsigned long bits = 0;
-
-#ifdef CONFIG_SMP
-        void psurge_smp_message_recv(struct pt_regs *);
-
-        /* IPI's are a hack on the powersurge -- Cort */
-        if ( smp_processor_id() != 0 ) {
-                psurge_smp_message_recv(regs);
-                return -2;      /* ignore, already handled */
-        }
-#endif /* CONFIG_SMP */
-        for (irq = max_real_irqs; (irq -= 32) >= 0; ) {
-                int i = irq >> 5;
-                bits = in_le32(&pmac_irq_hw[i]->event) | ppc_lost_interrupts[i];
-                /* We must read level interrupts from the level register */
-                bits |= (in_le32(&pmac_irq_hw[i]->level) & level_mask[i]);
-                bits &= ppc_cached_irq_mask[i];
-                if (bits == 0)
-                        continue;
-                irq += __ilog2(bits);
-                break;
-        }
-
-        return irq;
-}
-
-/* This routine will fix some missing interrupt values in the device tree
- * on the gatwick mac-io controller used by some PowerBooks
- */
-static void __init
-pmac_fix_gatwick_interrupts(struct device_node *gw, int irq_base)
-{
-        struct device_node *node;
-        int count;
-
-        memset(gatwick_int_pool, 0, sizeof(gatwick_int_pool));
-        node = gw->child;
-        count = 0;
-        while(node)
-        {
-                /* Fix SCC */
-                if (strcasecmp(node->name, "escc") == 0)
-                        if (node->child) {
-                                if (node->child->n_intrs < 3) {
-                                        node->child->intrs = &gatwick_int_pool[count];
-                                        count += 3;
-                                }
-                                node->child->n_intrs = 3;
-                                node->child->intrs[0].line = 15+irq_base;
-                                node->child->intrs[1].line =  4+irq_base;
-                                node->child->intrs[2].line =  5+irq_base;
-                                printk(KERN_INFO "irq: fixed SCC on second controller (%d,%d,%d)\n",
-                                        node->child->intrs[0].line,
-                                        node->child->intrs[1].line,
-                                        node->child->intrs[2].line);
-                        }
-                /* Fix media-bay & left SWIM */
-                if (strcasecmp(node->name, "media-bay") == 0) {
-                        struct device_node* ya_node;
-
-                        if (node->n_intrs == 0)
-                                node->intrs = &gatwick_int_pool[count++];
-                        node->n_intrs = 1;
-                        node->intrs[0].line = 29+irq_base;
-                        printk(KERN_INFO "irq: fixed media-bay on second controller (%d)\n",
-                                        node->intrs[0].line);
-
-                        ya_node = node->child;
-                        while(ya_node)
-                        {
-                                if (strcasecmp(ya_node->name, "floppy") == 0) {
-                                        if (ya_node->n_intrs < 2) {
-                                                ya_node->intrs = &gatwick_int_pool[count];
-                                                count += 2;
-                                        }
-                                        ya_node->n_intrs = 2;
-                                        ya_node->intrs[0].line = 19+irq_base;
-                                        ya_node->intrs[1].line =  1+irq_base;
-                                        printk(KERN_INFO "irq: fixed floppy on second controller (%d,%d)\n",
-                                                ya_node->intrs[0].line, ya_node->intrs[1].line);
-                                }
-                                if (strcasecmp(ya_node->name, "ata4") == 0) {
-                                        if (ya_node->n_intrs < 2) {
-                                                ya_node->intrs = &gatwick_int_pool[count];
-                                                count += 2;
-                                        }
-                                        ya_node->n_intrs = 2;
-                                        ya_node->intrs[0].line = 14+irq_base;
-                                        ya_node->intrs[1].line =  3+irq_base;
-                                        printk(KERN_INFO "irq: fixed ide on second controller (%d,%d)\n",
-                                                ya_node->intrs[0].line, ya_node->intrs[1].line);
-                                }
-                                ya_node = ya_node->sibling;
-                        }
-                }
-                node = node->sibling;
-        }
-        if (count > 10) {
-                printk("WARNING !! Gatwick interrupt pool overflow\n");
-                printk("  GATWICK_IRQ_POOL_SIZE = %d\n", GATWICK_IRQ_POOL_SIZE);
-                printk("              requested = %d\n", count);
-        }
-}
-
-/*
- * The PowerBook 3400/2400/3500 can have a combo ethernet/modem
- * card which includes an ohare chip that acts as a second interrupt
- * controller.  If we find this second ohare, set it up and fix the
- * interrupt value in the device tree for the ethernet chip.
- */
-static int __init enable_second_ohare(void)
-{
-        unsigned char bus, devfn;
-        unsigned short cmd;
-        unsigned long addr;
-        struct device_node *irqctrler = find_devices("pci106b,7");
-        struct device_node *ether;
-
-        if (irqctrler == NULL || irqctrler->n_addrs <= 0)
-                return -1;
-        addr = (unsigned long) ioremap(irqctrler->addrs[0].address, 0x40);
-        pmac_irq_hw[1] = (volatile struct pmac_irq_hw *)(addr + 0x20);
-        max_irqs = 64;
-        if (pci_device_from_OF_node(irqctrler, &bus, &devfn) == 0) {
-                struct pci_controller* hose = pci_find_hose_for_OF_device(irqctrler);
-                if (!hose)
-                    printk(KERN_ERR "Can't find PCI hose for OHare2 !\n");
-                else {
-                    early_read_config_word(hose, bus, devfn, PCI_COMMAND, &cmd);
-                    cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
-                    cmd &= ~PCI_COMMAND_IO;
-                    early_write_config_word(hose, bus, devfn, PCI_COMMAND, cmd);
-                }
-        }
-
-        /* Fix interrupt for the modem/ethernet combo controller. The number
-           in the device tree (27) is bogus (correct for the ethernet-only
-           board but not the combo ethernet/modem board).
-           The real interrupt is 28 on the second controller -> 28+32 = 60.
-        */
-        ether = find_devices("pci1011,14");
-        if (ether && ether->n_intrs > 0) {
-                ether->intrs[0].line = 60;
-                printk(KERN_INFO "irq: Fixed ethernet IRQ to %d\n",
-                       ether->intrs[0].line);
-        }
-
-        /* Return the interrupt number of the cascade */
-        return irqctrler->intrs[0].line;
-}
-
-#ifdef CONFIG_POWER4
-static irqreturn_t k2u3_action(int cpl, void *dev_id, struct pt_regs *regs)
-{
-        int irq;
-
-        irq = openpic2_get_irq(regs);
-        if (irq != -1)
-                __do_IRQ(irq, regs);
-        return IRQ_HANDLED;
-}
-
-static struct irqaction k2u3_cascade_action = {
-        .handler        = k2u3_action,
-        .flags          = 0,
-        .mask           = CPU_MASK_NONE,
-        .name           = "U3->K2 Cascade",
-};
-#endif /* CONFIG_POWER4 */
-
-#ifdef CONFIG_XMON
-static struct irqaction xmon_action = {
-        .handler        = xmon_irq,
-        .flags          = 0,
-        .mask           = CPU_MASK_NONE,
-        .name           = "NMI - XMON"
-};
-#endif
-
-static struct irqaction gatwick_cascade_action = {
-        .handler        = gatwick_action,
-        .flags          = SA_INTERRUPT,
-        .mask           = CPU_MASK_NONE,
-        .name           = "cascade",
-};
-
-void __init pmac_pic_init(void)
-{
-        int i;
-        struct device_node *irqctrler  = NULL;
-        struct device_node *irqctrler2 = NULL;
-        struct device_node *np;
-        unsigned long addr;
-        int irq_cascade = -1;
-
-        /* We first try to detect Apple's new Core99 chipset, since mac-io
-         * is quite different on those machines and contains an IBM MPIC2.
-         */
-        np = find_type_devices("open-pic");
-        while(np) {
-                if (np->parent && !strcmp(np->parent->name, "u3"))
-                        irqctrler2 = np;
-                else
-                        irqctrler = np;
-                np = np->next;
-        }
-        if (irqctrler != NULL)
-        {
-                if (irqctrler->n_addrs > 0)
-                {
-                        unsigned char senses[128];
-
-                        printk(KERN_INFO "PowerMac using OpenPIC irq controller at 0x%08x\n",
-                               irqctrler->addrs[0].address);
-
-                        prom_get_irq_senses(senses, 0, 128);
-                        OpenPIC_InitSenses = senses;
-                        OpenPIC_NumInitSenses = 128;
-                        ppc_md.get_irq = openpic_get_irq;
-                        pmac_call_feature(PMAC_FTR_ENABLE_MPIC, irqctrler, 0, 0);
-                        OpenPIC_Addr = ioremap(irqctrler->addrs[0].address,
-                                               irqctrler->addrs[0].size);
-                        openpic_init(0);
-
-#ifdef CONFIG_POWER4
-                        if (irqctrler2 != NULL && irqctrler2->n_intrs > 0 &&
-                            irqctrler2->n_addrs > 0) {
-                                printk(KERN_INFO "Slave OpenPIC at 0x%08x hooked on IRQ %d\n",
-                                       irqctrler2->addrs[0].address,
-                                       irqctrler2->intrs[0].line);
-                                pmac_call_feature(PMAC_FTR_ENABLE_MPIC, irqctrler2, 0, 0);
-                                OpenPIC2_Addr = ioremap(irqctrler2->addrs[0].address,
-                                                        irqctrler2->addrs[0].size);
-                                prom_get_irq_senses(senses, PMAC_OPENPIC2_OFFSET,
-                                                    PMAC_OPENPIC2_OFFSET+128);
-                                OpenPIC_InitSenses = senses;
-                                OpenPIC_NumInitSenses = 128;
-                                openpic2_init(PMAC_OPENPIC2_OFFSET);
-
-                                if (setup_irq(irqctrler2->intrs[0].line,
-                                              &k2u3_cascade_action))
-                                        printk("Unable to get OpenPIC IRQ for cascade\n");
-                        }
-#endif /* CONFIG_POWER4 */
-
-#ifdef CONFIG_XMON
-                        {
-                                struct device_node* pswitch;
-                                int nmi_irq;
-
-                                pswitch = find_devices("programmer-switch");
-                                if (pswitch && pswitch->n_intrs) {
-                                        nmi_irq = pswitch->intrs[0].line;
-                                        openpic_init_nmi_irq(nmi_irq);
-                                        setup_irq(nmi_irq, &xmon_action);
-                                }
-                        }
-#endif  /* CONFIG_XMON */
-                        return;
-                }
-                irqctrler = NULL;
-        }
-
-        /* Get the level/edge settings, assume if it's not
-         * a Grand Central nor an OHare, then it's an Heathrow
-         * (or Paddington).
-         */
-        if (find_devices("gc"))
-                level_mask[0] = GC_LEVEL_MASK;
-        else if (find_devices("ohare")) {
-                level_mask[0] = OHARE_LEVEL_MASK;
-                /* We might have a second cascaded ohare */
-                level_mask[1] = OHARE_LEVEL_MASK;
-        } else {
-                level_mask[0] = HEATHROW_LEVEL_MASK;
-                level_mask[1] = 0;
-                /* We might have a second cascaded heathrow */
-                level_mask[2] = HEATHROW_LEVEL_MASK;
-                level_mask[3] = 0;
-        }
-
-        /*
-         * G3 powermacs and 1999 G3 PowerBooks have 64 interrupts,
-         * 1998 G3 Series PowerBooks have 128,
-         * other powermacs have 32.
-         * The combo ethernet/modem card for the Powerstar powerbooks
-         * (2400/3400/3500, ohare based) has a second ohare chip
-         * effectively making a total of 64.
-         */
-        max_irqs = max_real_irqs = 32;
-        irqctrler = find_devices("mac-io");
-        if (irqctrler)
-        {
-                max_real_irqs = 64;
-                if (irqctrler->next)
-                        max_irqs = 128;
-                else
-                        max_irqs = 64;
-        }
-        for ( i = 0; i < max_real_irqs ; i++ )
-                irq_desc[i].handler = &pmac_pic;
-
-        /* get addresses of first controller */
-        if (irqctrler) {
-                if  (irqctrler->n_addrs > 0) {
-                        addr = (unsigned long)
-                                ioremap(irqctrler->addrs[0].address, 0x40);
-                        for (i = 0; i < 2; ++i)
-                                pmac_irq_hw[i] = (volatile struct pmac_irq_hw*)
-                                        (addr + (2 - i) * 0x10);
-                }
-
-                /* get addresses of second controller */
-                irqctrler = irqctrler->next;
-                if (irqctrler && irqctrler->n_addrs > 0) {
-                        addr = (unsigned long)
-                                ioremap(irqctrler->addrs[0].address, 0x40);
-                        for (i = 2; i < 4; ++i)
-                                pmac_irq_hw[i] = (volatile struct pmac_irq_hw*)
-                                        (addr + (4 - i) * 0x10);
-                        irq_cascade = irqctrler->intrs[0].line;
-                        if (device_is_compatible(irqctrler, "gatwick"))
-                                pmac_fix_gatwick_interrupts(irqctrler, max_real_irqs);
-                }
-        } else {
-                /* older powermacs have a GC (grand central) or ohare at
-                   f3000000, with interrupt control registers at f3000020. */
-                addr = (unsigned long) ioremap(0xf3000000, 0x40);
-                pmac_irq_hw[0] = (volatile struct pmac_irq_hw *) (addr + 0x20);
-        }
-
-        /* PowerBooks 3400 and 3500 can have a second controller in a second
-           ohare chip, on the combo ethernet/modem card */
-        if (machine_is_compatible("AAPL,3400/2400")
-             || machine_is_compatible("AAPL,3500"))
-                irq_cascade = enable_second_ohare();
-
-        /* disable all interrupts in all controllers */
-        for (i = 0; i * 32 < max_irqs; ++i)
-                out_le32(&pmac_irq_hw[i]->enable, 0);
-        /* mark level interrupts */
-        for (i = 0; i < max_irqs; i++)
-                if (level_mask[i >> 5] & (1UL << (i & 0x1f)))
-                        irq_desc[i].status = IRQ_LEVEL;
-
-        /* get interrupt line of secondary interrupt controller */
-        if (irq_cascade >= 0) {
-                printk(KERN_INFO "irq: secondary controller on irq %d\n",
-                        (int)irq_cascade);
-                for ( i = max_real_irqs ; i < max_irqs ; i++ )
-                        irq_desc[i].handler = &gatwick_pic;
-                setup_irq(irq_cascade, &gatwick_cascade_action);
-        }
-        printk("System has %d possible interrupts\n", max_irqs);
-        if (max_irqs != max_real_irqs)
-                printk(KERN_DEBUG "%d interrupts on main controller\n",
-                        max_real_irqs);
-
-#ifdef CONFIG_XMON
-        setup_irq(20, &xmon_action);
-#endif  /* CONFIG_XMON */
-}
-
-#ifdef CONFIG_PM
-/*
- * These procedures are used in implementing sleep on the powerbooks.
- * sleep_save_intrs() saves the states of all interrupt enables
- * and disables all interrupts except for the nominated one.
- * sleep_restore_intrs() restores the states of all interrupt enables.
- */
-unsigned long sleep_save_mask[2];
-
-/* This used to be passed by the PMU driver but that link got
- * broken with the new driver model. We use this tweak for now...
- */
-static int pmacpic_find_viaint(void)
-{
-        int viaint = -1;
-
-#ifdef CONFIG_ADB_PMU
-        struct device_node *np;
-
-        if (pmu_get_model() != PMU_OHARE_BASED)
-                goto not_found;
-        np = of_find_node_by_name(NULL, "via-pmu");
-        if (np == NULL)
-                goto not_found;
-        viaint = np->intrs[0].line;
-#endif /* CONFIG_ADB_PMU */
-
-not_found:
-        return viaint;
-}
-
-static int pmacpic_suspend(struct sys_device *sysdev, pm_message_t state)
-{
-        int viaint = pmacpic_find_viaint();
-
-        sleep_save_mask[0] = ppc_cached_irq_mask[0];
-        sleep_save_mask[1] = ppc_cached_irq_mask[1];
-        ppc_cached_irq_mask[0] = 0;
-        ppc_cached_irq_mask[1] = 0;
-        if (viaint > 0)
-                set_bit(viaint, ppc_cached_irq_mask);
-        out_le32(&pmac_irq_hw[0]->enable, ppc_cached_irq_mask[0]);
-        if (max_real_irqs > 32)
-                out_le32(&pmac_irq_hw[1]->enable, ppc_cached_irq_mask[1]);
-        (void)in_le32(&pmac_irq_hw[0]->event);
-        /* make sure mask gets to controller before we return to caller */
-        mb();
-        (void)in_le32(&pmac_irq_hw[0]->enable);
-
-        return 0;
-}
-
-static int pmacpic_resume(struct sys_device *sysdev)
-{
-        int i;
-
-        out_le32(&pmac_irq_hw[0]->enable, 0);
-        if (max_real_irqs > 32)
-                out_le32(&pmac_irq_hw[1]->enable, 0);
-        mb();
-        for (i = 0; i < max_real_irqs; ++i)
-                if (test_bit(i, sleep_save_mask))
-                        pmac_unmask_irq(i);
-
-        return 0;
-}
-
-#endif /* CONFIG_PM */
-
-static struct sysdev_class pmacpic_sysclass = {
-        set_kset_name("pmac_pic"),
-};
-
-static struct sys_device device_pmacpic = {
-        .id             = 0,
-        .cls            = &pmacpic_sysclass,
-};
-
-static struct sysdev_driver driver_pmacpic = {
-#ifdef CONFIG_PM
-        .suspend        = &pmacpic_suspend,
-        .resume         = &pmacpic_resume,
-#endif /* CONFIG_PM */
-};
-
-static int __init init_pmacpic_sysfs(void)
-{
-        if (max_irqs == 0)
-                return -ENODEV;
-
-        printk(KERN_DEBUG "Registering pmac pic with sysfs...\n");
-        sysdev_class_register(&pmacpic_sysclass);
-        sysdev_register(&device_pmacpic);
-        sysdev_driver_register(&pmacpic_sysclass, &driver_pmacpic);
-        return 0;
-}
-
-subsys_initcall(init_pmacpic_sysfs);
-
diff --git a/arch/ppc/platforms/pmac_pic.h b/arch/ppc/platforms/pmac_pic.h
deleted file mode 100644
index 664103dfeef9..000000000000
--- a/arch/ppc/platforms/pmac_pic.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef __PPC_PLATFORMS_PMAC_PIC_H
-#define __PPC_PLATFORMS_PMAC_PIC_H
-
-#include <linux/irq.h>
-
-extern struct hw_interrupt_type pmac_pic;
-
-void pmac_pic_init(void);
-int pmac_get_irq(struct pt_regs *regs);
-
-#endif /* __PPC_PLATFORMS_PMAC_PIC_H */
diff --git a/arch/ppc/platforms/pmac_setup.c b/arch/ppc/platforms/pmac_setup.c
deleted file mode 100644
index 55d2beffe560..000000000000
--- a/arch/ppc/platforms/pmac_setup.c
+++ /dev/null
@@ -1,745 +0,0 @@
-/*
- *  arch/ppc/platforms/setup.c
- *
- *  PowerPC version
- *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
- *
- *  Adapted for Power Macintosh by Paul Mackerras
- *    Copyright (C) 1996 Paul Mackerras (paulus@cs.anu.edu.au)
- *
- *  Derived from "arch/alpha/kernel/setup.c"
- *    Copyright (C) 1995 Linus Torvalds
- *
- *  Maintained by 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.
- *
- */
-
-/*
- * bootup setup stuff..
- */
-
-#include <linux/config.h>
-#include <linux/init.h>
-#include <linux/errno.h>
-#include <linux/sched.h>
-#include <linux/kernel.h>
-#include <linux/mm.h>
-#include <linux/stddef.h>
-#include <linux/unistd.h>
-#include <linux/ptrace.h>
-#include <linux/slab.h>
-#include <linux/user.h>
-#include <linux/a.out.h>
-#include <linux/tty.h>
-#include <linux/string.h>
-#include <linux/delay.h>
-#include <linux/ioport.h>
-#include <linux/major.h>
-#include <linux/initrd.h>
-#include <linux/vt_kern.h>
-#include <linux/console.h>
-#include <linux/ide.h>
-#include <linux/pci.h>
-#include <linux/adb.h>
-#include <linux/cuda.h>
-#include <linux/pmu.h>
-#include <linux/seq_file.h>
-#include <linux/root_dev.h>
-#include <linux/bitops.h>
-#include <linux/suspend.h>
-
-#include <asm/reg.h>
-#include <asm/sections.h>
-#include <asm/prom.h>
-#include <asm/system.h>
-#include <asm/pgtable.h>
-#include <asm/io.h>
-#include <asm/pci-bridge.h>
-#include <asm/ohare.h>
-#include <asm/mediabay.h>
-#include <asm/machdep.h>
-#include <asm/dma.h>
-#include <asm/bootx.h>
-#include <asm/cputable.h>
-#include <asm/btext.h>
-#include <asm/pmac_feature.h>
-#include <asm/time.h>
-#include <asm/of_device.h>
-#include <asm/mmu_context.h>
-
-#include "pmac_pic.h"
-#include "mem_pieces.h"
-
-#undef SHOW_GATWICK_IRQS
-
-extern long pmac_time_init(void);
-extern unsigned long pmac_get_rtc_time(void);
-extern int pmac_set_rtc_time(unsigned long nowtime);
-extern void pmac_read_rtc_time(void);
-extern void pmac_calibrate_decr(void);
-extern void pmac_pcibios_fixup(void);
-extern void pmac_find_bridges(void);
-extern unsigned long pmac_ide_get_base(int index);
-extern void pmac_ide_init_hwif_ports(hw_regs_t *hw,
-        unsigned long data_port, unsigned long ctrl_port, int *irq);
-
-extern void pmac_nvram_update(void);
-extern unsigned char pmac_nvram_read_byte(int addr);
-extern void pmac_nvram_write_byte(int addr, unsigned char val);
-extern int pmac_pci_enable_device_hook(struct pci_dev *dev, int initial);
-extern void pmac_pcibios_after_init(void);
-extern int of_show_percpuinfo(struct seq_file *m, int i);
-
-struct device_node *memory_node;
-
-unsigned char drive_info;
-
-int ppc_override_l2cr = 0;
-int ppc_override_l2cr_value;
-int has_l2cache = 0;
-
-static int current_root_goodness = -1;
-
-extern int pmac_newworld;
-
-#define DEFAULT_ROOT_DEVICE Root_SDA1   /* sda1 - slightly silly choice */
-
-extern void zs_kgdb_hook(int tty_num);
-static void ohare_init(void);
-#ifdef CONFIG_BOOTX_TEXT
-static void pmac_progress(char *s, unsigned short hex);
-#endif
-
-sys_ctrler_t sys_ctrler = SYS_CTRLER_UNKNOWN;
-
-#ifdef CONFIG_SMP
-extern struct smp_ops_t psurge_smp_ops;
-extern struct smp_ops_t core99_smp_ops;
-#endif /* CONFIG_SMP */
-
-static int
-pmac_show_cpuinfo(struct seq_file *m)
-{
-        struct device_node *np;
-        char *pp;
-        int plen;
-        int mbmodel = pmac_call_feature(PMAC_FTR_GET_MB_INFO,
-                NULL, PMAC_MB_INFO_MODEL, 0);
-        unsigned int mbflags = (unsigned int)pmac_call_feature(PMAC_FTR_GET_MB_INFO,
-                NULL, PMAC_MB_INFO_FLAGS, 0);
-        char* mbname;
-
-        if (pmac_call_feature(PMAC_FTR_GET_MB_INFO, NULL, PMAC_MB_INFO_NAME, (int)&mbname) != 0)
-                mbname = "Unknown";
-
-        /* find motherboard type */
-        seq_printf(m, "machine\t\t: ");
-        np = find_devices("device-tree");
-        if (np != NULL) {
-                pp = (char *) get_property(np, "model", NULL);
-                if (pp != NULL)
-                        seq_printf(m, "%s\n", pp);
-                else
-                        seq_printf(m, "PowerMac\n");
-                pp = (char *) get_property(np, "compatible", &plen);
-                if (pp != NULL) {
-                        seq_printf(m, "motherboard\t:");
-                        while (plen > 0) {
-                                int l = strlen(pp) + 1;
-                                seq_printf(m, " %s", pp);
-                                plen -= l;
-                                pp += l;
-                        }
-                        seq_printf(m, "\n");
-                }
-        } else
-                seq_printf(m, "PowerMac\n");
-
-        /* print parsed model */
-        seq_printf(m, "detected as\t: %d (%s)\n", mbmodel, mbname);
-        seq_printf(m, "pmac flags\t: %08x\n", mbflags);
-
-        /* find l2 cache info */
-        np = find_devices("l2-cache");
-        if (np == 0)
-                np = find_type_devices("cache");
-        if (np != 0) {
-                unsigned int *ic = (unsigned int *)
-                        get_property(np, "i-cache-size", NULL);
-                unsigned int *dc = (unsigned int *)
-                        get_property(np, "d-cache-size", NULL);
-                seq_printf(m, "L2 cache\t:");
-                has_l2cache = 1;
-                if (get_property(np, "cache-unified", NULL) != 0 && dc) {
-                        seq_printf(m, " %dK unified", *dc / 1024);
-                } else {
-                        if (ic)
-                                seq_printf(m, " %dK instruction", *ic / 1024);
-                        if (dc)
-                                seq_printf(m, "%s %dK data",
-                                           (ic? " +": ""), *dc / 1024);
-                }
-                pp = get_property(np, "ram-type", NULL);
-                if (pp)
-                        seq_printf(m, " %s", pp);
-                seq_printf(m, "\n");
-        }
-
-        /* find ram info */
-        np = find_devices("memory");
-        if (np != 0) {
-                int n;
-                struct reg_property *reg = (struct reg_property *)
-                        get_property(np, "reg", &n);
-
-                if (reg != 0) {
-                        unsigned long total = 0;
-
-                        for (n /= sizeof(struct reg_property); n > 0; --n)
-                                total += (reg++)->size;
-                        seq_printf(m, "memory\t\t: %luMB\n", total >> 20);
-                }
-        }
-
-        /* Checks "l2cr-value" property in the registry */
-        np = find_devices("cpus");
-        if (np == 0)
-                np = find_type_devices("cpu");
-        if (np != 0) {
-                unsigned int *l2cr = (unsigned int *)
-                        get_property(np, "l2cr-value", NULL);
-                if (l2cr != 0) {
-                        seq_printf(m, "l2cr override\t: 0x%x\n", *l2cr);
-                }
-        }
-
-        /* Indicate newworld/oldworld */
-        seq_printf(m, "pmac-generation\t: %s\n",
-                   pmac_newworld ? "NewWorld" : "OldWorld");
-
-
-        return 0;
-}
-
-static int
-pmac_show_percpuinfo(struct seq_file *m, int i)
-{
-#ifdef CONFIG_CPU_FREQ_PMAC
-        extern unsigned int pmac_get_one_cpufreq(int i);
-        unsigned int freq = pmac_get_one_cpufreq(i);
-        if (freq != 0) {
-                seq_printf(m, "clock\t\t: %dMHz\n", freq/1000);
-                return 0;
-        }
-#endif /* CONFIG_CPU_FREQ_PMAC */
-        return of_show_percpuinfo(m, i);
-}
-
-static volatile u32 *sysctrl_regs;
-
-void __init
-pmac_setup_arch(void)
-{
-        struct device_node *cpu;
-        int *fp;
-        unsigned long pvr;
-
-        pvr = PVR_VER(mfspr(SPRN_PVR));
-
-        /* Set loops_per_jiffy to a half-way reasonable value,
-           for use until calibrate_delay gets called. */
-        cpu = find_type_devices("cpu");
-        if (cpu != 0) {
-                fp = (int *) get_property(cpu, "clock-frequency", NULL);
-                if (fp != 0) {
-                        if (pvr == 4 || pvr >= 8)
-                                /* 604, G3, G4 etc. */
-                                loops_per_jiffy = *fp / HZ;
-                        else
-                                /* 601, 603, etc. */
-                                loops_per_jiffy = *fp / (2*HZ);
-                } else
-                        loops_per_jiffy = 50000000 / HZ;
-        }
-
-        /* this area has the CPU identification register
-           and some registers used by smp boards */
-        sysctrl_regs = (volatile u32 *) ioremap(0xf8000000, 0x1000);
-        ohare_init();
-
-        /* Lookup PCI hosts */
-        pmac_find_bridges();
-
-        /* Checks "l2cr-value" property in the registry */
-        if (cpu_has_feature(CPU_FTR_L2CR)) {
-                struct device_node *np = find_devices("cpus");
-                if (np == 0)
-                        np = find_type_devices("cpu");
-                if (np != 0) {
-                        unsigned int *l2cr = (unsigned int *)
-                                get_property(np, "l2cr-value", NULL);
-                        if (l2cr != 0) {
-                                ppc_override_l2cr = 1;
-                                ppc_override_l2cr_value = *l2cr;
-                                _set_L2CR(0);
-                                _set_L2CR(ppc_override_l2cr_value);
-                        }
-                }
-        }
-
-        if (ppc_override_l2cr)
-                printk(KERN_INFO "L2CR overriden (0x%x), backside cache is %s\n",
-                        ppc_override_l2cr_value, (ppc_override_l2cr_value & 0x80000000)
-                                ? "enabled" : "disabled");
-
-#ifdef CONFIG_KGDB
-        zs_kgdb_hook(0);
-#endif
-
-#ifdef CONFIG_ADB_CUDA
-        find_via_cuda();
-#else
-        if (find_devices("via-cuda")) {
-                printk("WARNING ! Your machine is Cuda based but your kernel\n");
-                printk("          wasn't compiled with CONFIG_ADB_CUDA option !\n");
-        }
-#endif
-#ifdef CONFIG_ADB_PMU
-        find_via_pmu();
-#else
-        if (find_devices("via-pmu")) {
-                printk("WARNING ! Your machine is PMU based but your kernel\n");
-                printk("          wasn't compiled with CONFIG_ADB_PMU option !\n");
-        }
-#endif
-#ifdef CONFIG_NVRAM
-        pmac_nvram_init();
-#endif
-#ifdef CONFIG_BLK_DEV_INITRD
-        if (initrd_start)
-                ROOT_DEV = Root_RAM0;
-        else
-#endif
-                ROOT_DEV = DEFAULT_ROOT_DEVICE;
-
-#ifdef CONFIG_SMP
-        /* Check for Core99 */
-        if (find_devices("uni-n") || find_devices("u3"))
-                smp_ops = &core99_smp_ops;
-        else
-                smp_ops = &psurge_smp_ops;
-#endif /* CONFIG_SMP */
-
-        pci_create_OF_bus_map();
-}
-
-static void __init ohare_init(void)
-{
-        /*
-         * Turn on the L2 cache.
-         * We assume that we have a PSX memory controller iff
-         * we have an ohare I/O controller.
-         */
-        if (find_devices("ohare") != NULL) {
-                if (((sysctrl_regs[2] >> 24) & 0xf) >= 3) {
-                        if (sysctrl_regs[4] & 0x10)
-                                sysctrl_regs[4] |= 0x04000020;
-                        else
-                                sysctrl_regs[4] |= 0x04000000;
-                        if(has_l2cache)
-                                printk(KERN_INFO "Level 2 cache enabled\n");
-                }
-        }
-}
-
-extern char *bootpath;
-extern char *bootdevice;
-void *boot_host;
-int boot_target;
-int boot_part;
-extern dev_t boot_dev;
-
-#ifdef CONFIG_SCSI
-void __init
-note_scsi_host(struct device_node *node, void *host)
-{
-        int l;
-        char *p;
-
-        l = strlen(node->full_name);
-        if (bootpath != NULL && bootdevice != NULL
-            && strncmp(node->full_name, bootdevice, l) == 0
-            && (bootdevice[l] == '/' || bootdevice[l] == 0)) {
-                boot_host = host;
-                /*
-                 * There's a bug in OF 1.0.5.  (Why am I not surprised.)
-                 * If you pass a path like scsi/sd@1:0 to canon, it returns
-                 * something like /bandit@F2000000/gc@10/53c94@10000/sd@0,0
-                 * That is, the scsi target number doesn't get preserved.
-                 * So we pick the target number out of bootpath and use that.
-                 */
-                p = strstr(bootpath, "/sd@");
-                if (p != NULL) {
-                        p += 4;
-                        boot_target = simple_strtoul(p, NULL, 10);
-                        p = strchr(p, ':');
-                        if (p != NULL)
-                                boot_part = simple_strtoul(p + 1, NULL, 10);
-                }
-        }
-}
-#endif
-
-#if defined(CONFIG_BLK_DEV_IDE) && defined(CONFIG_BLK_DEV_IDE_PMAC)
-static dev_t __init
-find_ide_boot(void)
-{
-        char *p;
-        int n;
-        dev_t __init pmac_find_ide_boot(char *bootdevice, int n);
-
-        if (bootdevice == NULL)
-                return 0;
-        p = strrchr(bootdevice, '/');
-        if (p == NULL)
-                return 0;
-        n = p - bootdevice;
-
-        return pmac_find_ide_boot(bootdevice, n);
-}
-#endif /* CONFIG_BLK_DEV_IDE && CONFIG_BLK_DEV_IDE_PMAC */
-
-static void __init
-find_boot_device(void)
-{
-#if defined(CONFIG_BLK_DEV_IDE) && defined(CONFIG_BLK_DEV_IDE_PMAC)
-        boot_dev = find_ide_boot();
-#endif
-}
-
-static int initializing = 1;
-/* TODO: Merge the suspend-to-ram with the common code !!!
- * currently, this is a stub implementation for suspend-to-disk
- * only
- */
-
-#ifdef CONFIG_SOFTWARE_SUSPEND
-
-static int pmac_pm_prepare(suspend_state_t state)
-{
-        printk(KERN_DEBUG "%s(%d)\n", __FUNCTION__, state);
-
-        return 0;
-}
-
-static int pmac_pm_enter(suspend_state_t state)
-{
-        printk(KERN_DEBUG "%s(%d)\n", __FUNCTION__, state);
-
-        /* Giveup the lazy FPU & vec so we don't have to back them
-         * up from the low level code
-         */
-        enable_kernel_fp();
-
-#ifdef CONFIG_ALTIVEC
-        if (cur_cpu_spec->cpu_features & CPU_FTR_ALTIVEC)
-                enable_kernel_altivec();
-#endif /* CONFIG_ALTIVEC */
-
-        return 0;
-}
-
-static int pmac_pm_finish(suspend_state_t state)
-{
-        printk(KERN_DEBUG "%s(%d)\n", __FUNCTION__, state);
-
-        /* Restore userland MMU context */
-        set_context(current->active_mm->context, current->active_mm->pgd);
-
-        return 0;
-}
-
-static struct pm_ops pmac_pm_ops = {
-        .pm_disk_mode   = PM_DISK_SHUTDOWN,
-        .prepare        = pmac_pm_prepare,
-        .enter          = pmac_pm_enter,
-        .finish         = pmac_pm_finish,
-};
-
-#endif /* CONFIG_SOFTWARE_SUSPEND */
-
-static int pmac_late_init(void)
-{
-        initializing = 0;
-#ifdef CONFIG_SOFTWARE_SUSPEND
-        pm_set_ops(&pmac_pm_ops);
-#endif /* CONFIG_SOFTWARE_SUSPEND */
-        return 0;
-}
-
-late_initcall(pmac_late_init);
-
-/* can't be __init - can be called whenever a disk is first accessed */
-void
-note_bootable_part(dev_t dev, int part, int goodness)
-{
-        static int found_boot = 0;
-        char *p;
-
-        if (!initializing)
-                return;
-        if ((goodness <= current_root_goodness) &&
-            ROOT_DEV != DEFAULT_ROOT_DEVICE)
-                return;
-        p = strstr(saved_command_line, "root=");
-        if (p != NULL && (p == saved_command_line || p[-1] == ' '))
-                return;
-
-        if (!found_boot) {
-                find_boot_device();
-                found_boot = 1;
-        }
-        if (!boot_dev || dev == boot_dev) {
-                ROOT_DEV = dev + part;
-                boot_dev = 0;
-                current_root_goodness = goodness;
-        }
-}
-
-static void
-pmac_restart(char *cmd)
-{
-#ifdef CONFIG_ADB_CUDA
-        struct adb_request req;
-#endif /* CONFIG_ADB_CUDA */
-
-        switch (sys_ctrler) {
-#ifdef CONFIG_ADB_CUDA
-        case SYS_CTRLER_CUDA:
-                cuda_request(&req, NULL, 2, CUDA_PACKET,
-                             CUDA_RESET_SYSTEM);
-                for (;;)
-                        cuda_poll();
-                break;
-#endif /* CONFIG_ADB_CUDA */
-#ifdef CONFIG_ADB_PMU
-        case SYS_CTRLER_PMU:
-                pmu_restart();
-                break;
-#endif /* CONFIG_ADB_PMU */
-        default: ;
-        }
-}
-
-static void
-pmac_power_off(void)
-{
-#ifdef CONFIG_ADB_CUDA
-        struct adb_request req;
-#endif /* CONFIG_ADB_CUDA */
-
-        switch (sys_ctrler) {
-#ifdef CONFIG_ADB_CUDA
-        case SYS_CTRLER_CUDA:
-                cuda_request(&req, NULL, 2, CUDA_PACKET,
-                             CUDA_POWERDOWN);
-                for (;;)
-                        cuda_poll();
-                break;
-#endif /* CONFIG_ADB_CUDA */
-#ifdef CONFIG_ADB_PMU
-        case SYS_CTRLER_PMU:
-                pmu_shutdown();
-                break;
-#endif /* CONFIG_ADB_PMU */
-        default: ;
-        }
-}
-
-static void
-pmac_halt(void)
-{
-   pmac_power_off();
-}
-
-/*
- * Read in a property describing some pieces of memory.
- */
-
-static int __init
-get_mem_prop(char *name, struct mem_pieces *mp)
-{
-        struct reg_property *rp;
-        int i, s;
-        unsigned int *ip;
-        int nac = prom_n_addr_cells(memory_node);
-        int nsc = prom_n_size_cells(memory_node);
-
-        ip = (unsigned int *) get_property(memory_node, name, &s);
-        if (ip == NULL) {
-                printk(KERN_ERR "error: couldn't get %s property on /memory\n",
-                       name);
-                return 0;
-        }
-        s /= (nsc + nac) * 4;
-        rp = mp->regions;
-        for (i = 0; i < s; ++i, ip += nac+nsc) {
-                if (nac >= 2 && ip[nac-2] != 0)
-                        continue;
-                rp->address = ip[nac-1];
-                if (nsc >= 2 && ip[nac+nsc-2] != 0)
-                        rp->size = ~0U;
-                else
-                        rp->size = ip[nac+nsc-1];
-                ++rp;
-        }
-        mp->n_regions = rp - mp->regions;
-
-        /* Make sure the pieces are sorted. */
-        mem_pieces_sort(mp);
-        mem_pieces_coalesce(mp);
-        return 1;
-}
-
-/*
- * On systems with Open Firmware, collect information about
- * physical RAM and which pieces are already in use.
- * At this point, we have (at least) the first 8MB mapped with a BAT.
- * Our text, data, bss use something over 1MB, starting at 0.
- * Open Firmware may be using 1MB at the 4MB point.
- */
-unsigned long __init
-pmac_find_end_of_memory(void)
-{
-        unsigned long a, total;
-        struct mem_pieces phys_mem;
-
-        /*
-         * Find out where physical memory is, and check that it
-         * starts at 0 and is contiguous.  It seems that RAM is
-         * always physically contiguous on Power Macintoshes.
-         *
-         * Supporting discontiguous physical memory isn't hard,
-         * it just makes the virtual <-> physical mapping functions
-         * more complicated (or else you end up wasting space
-         * in mem_map).
-         */
-        memory_node = find_devices("memory");
-        if (memory_node == NULL || !get_mem_prop("reg", &phys_mem)
-            || phys_mem.n_regions == 0)
-                panic("No RAM??");
-        a = phys_mem.regions[0].address;
-        if (a != 0)
-                panic("RAM doesn't start at physical address 0");
-        total = phys_mem.regions[0].size;
-
-        if (phys_mem.n_regions > 1) {
-                printk("RAM starting at 0x%x is not contiguous\n",
-                       phys_mem.regions[1].address);
-                printk("Using RAM from 0 to 0x%lx\n", total-1);
-        }
-
-        return total;
-}
-
-void __init
-pmac_init(unsigned long r3, unsigned long r4, unsigned long r5,
-          unsigned long r6, unsigned long r7)
-{
-        /* isa_io_base gets set in pmac_find_bridges */
-        isa_mem_base = PMAC_ISA_MEM_BASE;
-        pci_dram_offset = PMAC_PCI_DRAM_OFFSET;
-        ISA_DMA_THRESHOLD = ~0L;
-        DMA_MODE_READ = 1;
-        DMA_MODE_WRITE = 2;
-
-        ppc_md.setup_arch     = pmac_setup_arch;
-        ppc_md.show_cpuinfo   = pmac_show_cpuinfo;
-        ppc_md.show_percpuinfo = pmac_show_percpuinfo;
-        ppc_md.init_IRQ       = pmac_pic_init;
-        ppc_md.get_irq        = pmac_get_irq; /* Changed later on ... */
-
-        ppc_md.pcibios_fixup  = pmac_pcibios_fixup;
-        ppc_md.pcibios_enable_device_hook = pmac_pci_enable_device_hook;
-        ppc_md.pcibios_after_init = pmac_pcibios_after_init;
-        ppc_md.phys_mem_access_prot = pci_phys_mem_access_prot;
-
-        ppc_md.restart        = pmac_restart;
-        ppc_md.power_off      = pmac_power_off;
-        ppc_md.halt           = pmac_halt;
-
-        ppc_md.time_init      = pmac_time_init;
-        ppc_md.set_rtc_time   = pmac_set_rtc_time;
-        ppc_md.get_rtc_time   = pmac_get_rtc_time;
-        ppc_md.calibrate_decr = pmac_calibrate_decr;
-
-        ppc_md.find_end_of_memory = pmac_find_end_of_memory;
-
-        ppc_md.feature_call   = pmac_do_feature_call;
-
-#if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE)
-#ifdef CONFIG_BLK_DEV_IDE_PMAC
-        ppc_ide_md.ide_init_hwif        = pmac_ide_init_hwif_ports;
-        ppc_ide_md.default_io_base      = pmac_ide_get_base;
-#endif /* CONFIG_BLK_DEV_IDE_PMAC */
-#endif /* defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE) */
-
-#ifdef CONFIG_BOOTX_TEXT
-        ppc_md.progress = pmac_progress;
-#endif /* CONFIG_BOOTX_TEXT */
-
-        if (ppc_md.progress) ppc_md.progress("pmac_init(): exit", 0);
-
-}
-
-#ifdef CONFIG_BOOTX_TEXT
-static void __init
-pmac_progress(char *s, unsigned short hex)
-{
-        if (boot_text_mapped) {
-                btext_drawstring(s);
-                btext_drawchar('\n');
-        }
-}
-#endif /* CONFIG_BOOTX_TEXT */
-
-static int __init
-pmac_declare_of_platform_devices(void)
-{
-        struct device_node *np;
-
-        np = find_devices("uni-n");
-        if (np) {
-                for (np = np->child; np != NULL; np = np->sibling)
-                        if (strncmp(np->name, "i2c", 3) == 0) {
-                                of_platform_device_create(np, "uni-n-i2c",
-                                                          NULL);
-                                break;
-                        }
-        }
-        np = find_devices("u3");
-        if (np) {
-                for (np = np->child; np != NULL; np = np->sibling)
-                        if (strncmp(np->name, "i2c", 3) == 0) {
-                                of_platform_device_create(np, "u3-i2c",
-                                                          NULL);
-                                break;
-                        }
-        }
-
-        np = find_devices("valkyrie");
-        if (np)
-                of_platform_device_create(np, "valkyrie", NULL);
-        np = find_devices("platinum");
-        if (np)
-                of_platform_device_create(np, "platinum", NULL);
-
-        return 0;
-}
-
-device_initcall(pmac_declare_of_platform_devices);
diff --git a/arch/ppc/platforms/pmac_sleep.S b/arch/ppc/platforms/pmac_sleep.S
deleted file mode 100644
index 22b113d19b24..000000000000
--- a/arch/ppc/platforms/pmac_sleep.S
+++ /dev/null
@@ -1,396 +0,0 @@
-/*
- * This file contains sleep low-level functions for PowerBook G3.
- *    Copyright (C) 1999 Benjamin Herrenschmidt (benh@kernel.crashing.org)
- *    and Paul Mackerras (paulus@samba.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.
- *
- */
-
-#include <linux/config.h>
-#include <asm/processor.h>
-#include <asm/page.h>
-#include <asm/ppc_asm.h>
-#include <asm/cputable.h>
-#include <asm/cache.h>
-#include <asm/thread_info.h>
-#include <asm/asm-offsets.h>
-
-#define MAGIC   0x4c617273      /* 'Lars' */
-
-/*
- * Structure for storing CPU registers on the stack.
- */
-#define SL_SP           0
-#define SL_PC           4
-#define SL_MSR          8
-#define SL_SDR1         0xc
-#define SL_SPRG0        0x10    /* 4 sprg's */
-#define SL_DBAT0        0x20
-#define SL_IBAT0        0x28
-#define SL_DBAT1        0x30
-#define SL_IBAT1        0x38
-#define SL_DBAT2        0x40
-#define SL_IBAT2        0x48
-#define SL_DBAT3        0x50
-#define SL_IBAT3        0x58
-#define SL_TB           0x60
-#define SL_R2           0x68
-#define SL_CR           0x6c
-#define SL_R12          0x70    /* r12 to r31 */
-#define SL_SIZE         (SL_R12 + 80)
-
-        .section .text
-        .align  5
-
-#if defined(CONFIG_PM) || defined(CONFIG_CPU_FREQ_PMAC)
-
-/* This gets called by via-pmu.c late during the sleep process.
- * The PMU was already send the sleep command and will shut us down
- * soon. We need to save all that is needed and setup the wakeup
- * vector that will be called by the ROM on wakeup
- */
-_GLOBAL(low_sleep_handler)
-#ifndef CONFIG_6xx
-        blr
-#else
-        mflr    r0
-        stw     r0,4(r1)
-        stwu    r1,-SL_SIZE(r1)
-        mfcr    r0
-        stw     r0,SL_CR(r1)
-        stw     r2,SL_R2(r1)
-        stmw    r12,SL_R12(r1)
-
-        /* Save MSR & SDR1 */
-        mfmsr   r4
-        stw     r4,SL_MSR(r1)
-        mfsdr1  r4
-        stw     r4,SL_SDR1(r1)
-
-        /* Get a stable timebase and save it */
-1:      mftbu   r4
-        stw     r4,SL_TB(r1)
-        mftb    r5
-        stw     r5,SL_TB+4(r1)
-        mftbu   r3
-        cmpw    r3,r4
-        bne     1b
-
-        /* Save SPRGs */
-        mfsprg  r4,0
-        stw     r4,SL_SPRG0(r1)
-        mfsprg  r4,1
-        stw     r4,SL_SPRG0+4(r1)
-        mfsprg  r4,2
-        stw     r4,SL_SPRG0+8(r1)
-        mfsprg  r4,3
-        stw     r4,SL_SPRG0+12(r1)
-
-        /* Save BATs */
-        mfdbatu r4,0
-        stw     r4,SL_DBAT0(r1)
-        mfdbatl r4,0
-        stw     r4,SL_DBAT0+4(r1)
-        mfdbatu r4,1
-        stw     r4,SL_DBAT1(r1)
-        mfdbatl r4,1
-        stw     r4,SL_DBAT1+4(r1)
-        mfdbatu r4,2
-        stw     r4,SL_DBAT2(r1)
-        mfdbatl r4,2
-        stw     r4,SL_DBAT2+4(r1)
-        mfdbatu r4,3
-        stw     r4,SL_DBAT3(r1)
-        mfdbatl r4,3
-        stw     r4,SL_DBAT3+4(r1)
-        mfibatu r4,0
-        stw     r4,SL_IBAT0(r1)
-        mfibatl r4,0
-        stw     r4,SL_IBAT0+4(r1)
-        mfibatu r4,1
-        stw     r4,SL_IBAT1(r1)
-        mfibatl r4,1
-        stw     r4,SL_IBAT1+4(r1)
-        mfibatu r4,2
-        stw     r4,SL_IBAT2(r1)
-        mfibatl r4,2
-        stw     r4,SL_IBAT2+4(r1)
-        mfibatu r4,3
-        stw     r4,SL_IBAT3(r1)
-        mfibatl r4,3
-        stw     r4,SL_IBAT3+4(r1)
-
-        /* Backup various CPU config stuffs */
-        bl      __save_cpu_setup
-
-        /* The ROM can wake us up via 2 different vectors:
-         *  - On wallstreet & lombard, we must write a magic
-         *    value 'Lars' at address 4 and a pointer to a
-         *    memory location containing the PC to resume from
-         *    at address 0.
-         *  - On Core99, we must store the wakeup vector at
-         *    address 0x80 and eventually it's parameters
-         *    at address 0x84. I've have some trouble with those
-         *    parameters however and I no longer use them.
-         */
-        lis     r5,grackle_wake_up@ha
-        addi    r5,r5,grackle_wake_up@l
-        tophys(r5,r5)
-        stw     r5,SL_PC(r1)
-        lis     r4,KERNELBASE@h
-        tophys(r5,r1)
-        addi    r5,r5,SL_PC
-        lis     r6,MAGIC@ha
-        addi    r6,r6,MAGIC@l
-        stw     r5,0(r4)
-        stw     r6,4(r4)
-        /* Setup stuffs at 0x80-0x84 for Core99 */
-        lis     r3,core99_wake_up@ha
-        addi    r3,r3,core99_wake_up@l
-        tophys(r3,r3)
-        stw     r3,0x80(r4)
-        stw     r5,0x84(r4)
-        /* Store a pointer to our backup storage into
-         * a kernel global
-         */
-        lis r3,sleep_storage@ha
-        addi r3,r3,sleep_storage@l
-        stw r5,0(r3)
-
-        .globl  low_cpu_die
-low_cpu_die:
-        /* Flush & disable all caches */
-        bl      flush_disable_caches
-
-        /* Turn off data relocation. */
-        mfmsr   r3              /* Save MSR in r7 */
-        rlwinm  r3,r3,0,28,26   /* Turn off DR bit */
-        sync
-        mtmsr   r3
-        isync
-
-BEGIN_FTR_SECTION
-        /* Flush any pending L2 data prefetches to work around HW bug */
-        sync
-        lis     r3,0xfff0
-        lwz     r0,0(r3)        /* perform cache-inhibited load to ROM */
-        sync                    /* (caches are disabled at this point) */
-END_FTR_SECTION_IFSET(CPU_FTR_SPEC7450)
-
-/*
- * Set the HID0 and MSR for sleep.
- */
-        mfspr   r2,SPRN_HID0
-        rlwinm  r2,r2,0,10,7    /* clear doze, nap */
-        oris    r2,r2,HID0_SLEEP@h
-        sync
-        isync
-        mtspr   SPRN_HID0,r2
-        sync
-
-/* This loop puts us back to sleep in case we have a spurrious
- * wakeup so that the host bridge properly stays asleep. The
- * CPU will be turned off, either after a known time (about 1
- * second) on wallstreet & lombard, or as soon as the CPU enters
- * SLEEP mode on core99
- */
-        mfmsr   r2
-        oris    r2,r2,MSR_POW@h
-1:      sync
-        mtmsr   r2
-        isync
-        b       1b
-
-/*
- * Here is the resume code.
- */
-
-
-/*
- * Core99 machines resume here
- * r4 has the physical address of SL_PC(sp) (unused)
- */
-_GLOBAL(core99_wake_up)
-        /* Make sure HID0 no longer contains any sleep bit and that data cache
-         * is disabled
-         */
-        mfspr   r3,SPRN_HID0
-        rlwinm  r3,r3,0,11,7            /* clear SLEEP, NAP, DOZE bits */
-        rlwinm  3,r3,0,18,15            /* clear DCE, ICE */
-        mtspr   SPRN_HID0,r3
-        sync
-        isync
-
-        /* sanitize MSR */
-        mfmsr   r3
-        ori     r3,r3,MSR_EE|MSR_IP
-        xori    r3,r3,MSR_EE|MSR_IP
-        sync
-        isync
-        mtmsr   r3
-        sync
-        isync
-
-        /* Recover sleep storage */
-        lis     r3,sleep_storage@ha
-        addi    r3,r3,sleep_storage@l
-        tophys(r3,r3)
-        lwz     r1,0(r3)
-
-        /* Pass thru to older resume code ... */
-/*
- * Here is the resume code for older machines.
- * r1 has the physical address of SL_PC(sp).
- */
-
-grackle_wake_up:
-
-        /* Restore the kernel's segment registers before
-         * we do any r1 memory access as we are not sure they
-         * are in a sane state above the first 256Mb region
-         */
-        li      r0,16           /* load up segment register values */
-        mtctr   r0              /* for context 0 */
-        lis     r3,0x2000       /* Ku = 1, VSID = 0 */
-        li      r4,0
-3:      mtsrin  r3,r4
-        addi    r3,r3,0x111     /* increment VSID */
-        addis   r4,r4,0x1000    /* address of next segment */
-        bdnz    3b
-        sync
-        isync
-
-        subi    r1,r1,SL_PC
-
-        /* Restore various CPU config stuffs */
-        bl      __restore_cpu_setup
-
-        /* Make sure all FPRs have been initialized */
-        bl      reloc_offset
-        bl      __init_fpu_registers
-
-        /* Invalidate & enable L1 cache, we don't care about
-         * whatever the ROM may have tried to write to memory
-         */
-        bl      __inval_enable_L1
-
-        /* Restore the BATs, and SDR1.  Then we can turn on the MMU. */
-        lwz     r4,SL_SDR1(r1)
-        mtsdr1  r4
-        lwz     r4,SL_SPRG0(r1)
-        mtsprg  0,r4
-        lwz     r4,SL_SPRG0+4(r1)
-        mtsprg  1,r4
-        lwz     r4,SL_SPRG0+8(r1)
-        mtsprg  2,r4
-        lwz     r4,SL_SPRG0+12(r1)
-        mtsprg  3,r4
-
-        lwz     r4,SL_DBAT0(r1)
-        mtdbatu 0,r4
-        lwz     r4,SL_DBAT0+4(r1)
-        mtdbatl 0,r4
-        lwz     r4,SL_DBAT1(r1)
-        mtdbatu 1,r4
-        lwz     r4,SL_DBAT1+4(r1)
-        mtdbatl 1,r4
-        lwz     r4,SL_DBAT2(r1)
-        mtdbatu 2,r4
-        lwz     r4,SL_DBAT2+4(r1)
-        mtdbatl 2,r4
-        lwz     r4,SL_DBAT3(r1)
-        mtdbatu 3,r4
-        lwz     r4,SL_DBAT3+4(r1)
-        mtdbatl 3,r4
-        lwz     r4,SL_IBAT0(r1)
-        mtibatu 0,r4
-        lwz     r4,SL_IBAT0+4(r1)
-        mtibatl 0,r4
-        lwz     r4,SL_IBAT1(r1)
-        mtibatu 1,r4
-        lwz     r4,SL_IBAT1+4(r1)
-        mtibatl 1,r4
-        lwz     r4,SL_IBAT2(r1)
-        mtibatu 2,r4
-        lwz     r4,SL_IBAT2+4(r1)
-        mtibatl 2,r4
-        lwz     r4,SL_IBAT3(r1)
-        mtibatu 3,r4
-        lwz     r4,SL_IBAT3+4(r1)
-        mtibatl 3,r4
-
-BEGIN_FTR_SECTION
-        li      r4,0
-        mtspr   SPRN_DBAT4U,r4
-        mtspr   SPRN_DBAT4L,r4
-        mtspr   SPRN_DBAT5U,r4
-        mtspr   SPRN_DBAT5L,r4
-        mtspr   SPRN_DBAT6U,r4
-        mtspr   SPRN_DBAT6L,r4
-        mtspr   SPRN_DBAT7U,r4
-        mtspr   SPRN_DBAT7L,r4
-        mtspr   SPRN_IBAT4U,r4
-        mtspr   SPRN_IBAT4L,r4
-        mtspr   SPRN_IBAT5U,r4
-        mtspr   SPRN_IBAT5L,r4
-        mtspr   SPRN_IBAT6U,r4
-        mtspr   SPRN_IBAT6L,r4
-        mtspr   SPRN_IBAT7U,r4
-        mtspr   SPRN_IBAT7L,r4
-END_FTR_SECTION_IFSET(CPU_FTR_HAS_HIGH_BATS)
-
-        /* Flush all TLBs */
-        lis     r4,0x1000
-1:      addic.  r4,r4,-0x1000
-        tlbie   r4
-        blt     1b
-        sync
-
-        /* restore the MSR and turn on the MMU */
-        lwz     r3,SL_MSR(r1)
-        bl      turn_on_mmu
-
-        /* get back the stack pointer */
-        tovirt(r1,r1)
-
-        /* Restore TB */
-        li      r3,0
-        mttbl   r3
-        lwz     r3,SL_TB(r1)
-        lwz     r4,SL_TB+4(r1)
-        mttbu   r3
-        mttbl   r4
-
-        /* Restore the callee-saved registers and return */
-        lwz     r0,SL_CR(r1)
-        mtcr    r0
-        lwz     r2,SL_R2(r1)
-        lmw     r12,SL_R12(r1)
-        addi    r1,r1,SL_SIZE
-        lwz     r0,4(r1)
-        mtlr    r0
-        blr
-
-turn_on_mmu:
-        mflr    r4
-        tovirt(r4,r4)
-        mtsrr0  r4
-        mtsrr1  r3
-        sync
-        isync
-        rfi
-
-#endif /* defined(CONFIG_PM) || defined(CONFIG_CPU_FREQ) */
-
-        .section .data
-        .balign L1_CACHE_BYTES
-sleep_storage:
-        .long 0
-        .balign L1_CACHE_BYTES, 0
-
-#endif /* CONFIG_6xx */
-        .section .text
diff --git a/arch/ppc/platforms/pmac_smp.c b/arch/ppc/platforms/pmac_smp.c
deleted file mode 100644
index 26ff26238f03..000000000000
--- a/arch/ppc/platforms/pmac_smp.c
+++ /dev/null
@@ -1,692 +0,0 @@
-/*
- * SMP support for power macintosh.
- *
- * We support both the old "powersurge" SMP architecture
- * and the current Core99 (G4 PowerMac) machines.
- *
- * Note that we don't support the very first rev. of
- * Apple/DayStar 2 CPUs board, the one with the funky
- * watchdog. Hopefully, none of these should be there except
- * maybe internally to Apple. I should probably still add some
- * code to detect this card though and disable SMP. --BenH.
- *
- * Support Macintosh G4 SMP by Troy Benjegerdes (hozer@drgw.net)
- * and Ben Herrenschmidt <benh@kernel.crashing.org>.
- *
- * Support for DayStar quad CPU cards
- * Copyright (C) XLR8, Inc. 1994-2000
- *
- *  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 <linux/config.h>
-#include <linux/kernel.h>
-#include <linux/sched.h>
-#include <linux/smp.h>
-#include <linux/smp_lock.h>
-#include <linux/interrupt.h>
-#include <linux/kernel_stat.h>
-#include <linux/delay.h>
-#include <linux/init.h>
-#include <linux/spinlock.h>
-#include <linux/errno.h>
-#include <linux/hardirq.h>
-#include <linux/cpu.h>
-
-#include <asm/ptrace.h>
-#include <asm/atomic.h>
-#include <asm/irq.h>
-#include <asm/page.h>
-#include <asm/pgtable.h>
-#include <asm/sections.h>
-#include <asm/io.h>
-#include <asm/prom.h>
-#include <asm/smp.h>
-#include <asm/residual.h>
-#include <asm/machdep.h>
-#include <asm/pmac_feature.h>
-#include <asm/time.h>
-#include <asm/open_pic.h>
-#include <asm/cacheflush.h>
-#include <asm/keylargo.h>
-
-/*
- * Powersurge (old powermac SMP) support.
- */
-
-extern void __secondary_start_pmac_0(void);
-
-/* Addresses for powersurge registers */
-#define HAMMERHEAD_BASE         0xf8000000
-#define HHEAD_CONFIG            0x90
-#define HHEAD_SEC_INTR          0xc0
-
-/* register for interrupting the primary processor on the powersurge */
-/* N.B. this is actually the ethernet ROM! */
-#define PSURGE_PRI_INTR         0xf3019000
-
-/* register for storing the start address for the secondary processor */
-/* N.B. this is the PCI config space address register for the 1st bridge */
-#define PSURGE_START            0xf2800000
-
-/* Daystar/XLR8 4-CPU card */
-#define PSURGE_QUAD_REG_ADDR    0xf8800000
-
-#define PSURGE_QUAD_IRQ_SET     0
-#define PSURGE_QUAD_IRQ_CLR     1
-#define PSURGE_QUAD_IRQ_PRIMARY 2
-#define PSURGE_QUAD_CKSTOP_CTL  3
-#define PSURGE_QUAD_PRIMARY_ARB 4
-#define PSURGE_QUAD_BOARD_ID    6
-#define PSURGE_QUAD_WHICH_CPU   7
-#define PSURGE_QUAD_CKSTOP_RDBK 8
-#define PSURGE_QUAD_RESET_CTL   11
-
-#define PSURGE_QUAD_OUT(r, v)   (out_8(quad_base + ((r) << 4) + 4, (v)))
-#define PSURGE_QUAD_IN(r)       (in_8(quad_base + ((r) << 4) + 4) & 0x0f)
-#define PSURGE_QUAD_BIS(r, v)   (PSURGE_QUAD_OUT((r), PSURGE_QUAD_IN(r) | (v)))
-#define PSURGE_QUAD_BIC(r, v)   (PSURGE_QUAD_OUT((r), PSURGE_QUAD_IN(r) & ~(v)))
-
-/* virtual addresses for the above */
-static volatile u8 __iomem *hhead_base;
-static volatile u8 __iomem *quad_base;
-static volatile u32 __iomem *psurge_pri_intr;
-static volatile u8 __iomem *psurge_sec_intr;
-static volatile u32 __iomem *psurge_start;
-
-/* values for psurge_type */
-#define PSURGE_NONE             -1
-#define PSURGE_DUAL             0
-#define PSURGE_QUAD_OKEE        1
-#define PSURGE_QUAD_COTTON      2
-#define PSURGE_QUAD_ICEGRASS    3
-
-/* what sort of powersurge board we have */
-static int psurge_type = PSURGE_NONE;
-
-/* L2 and L3 cache settings to pass from CPU0 to CPU1 */
-volatile static long int core99_l2_cache;
-volatile static long int core99_l3_cache;
-
-/* Timebase freeze GPIO */
-static unsigned int core99_tb_gpio;
-
-/* Sync flag for HW tb sync */
-static volatile int sec_tb_reset = 0;
-static unsigned int pri_tb_hi, pri_tb_lo;
-static unsigned int pri_tb_stamp;
-
-static void __devinit core99_init_caches(int cpu)
-{
-        if (!cpu_has_feature(CPU_FTR_L2CR))
-                return;
-
-        if (cpu == 0) {
-                core99_l2_cache = _get_L2CR();
-                printk("CPU0: L2CR is %lx\n", core99_l2_cache);
-        } else {
-                printk("CPU%d: L2CR was %lx\n", cpu, _get_L2CR());
-                _set_L2CR(0);
-                _set_L2CR(core99_l2_cache);
-                printk("CPU%d: L2CR set to %lx\n", cpu, core99_l2_cache);
-        }
-
-        if (!cpu_has_feature(CPU_FTR_L3CR))
-                return;
-
-        if (cpu == 0){
-                core99_l3_cache = _get_L3CR();
-                printk("CPU0: L3CR is %lx\n", core99_l3_cache);
-        } else {
-                printk("CPU%d: L3CR was %lx\n", cpu, _get_L3CR());
-                _set_L3CR(0);
-                _set_L3CR(core99_l3_cache);
-                printk("CPU%d: L3CR set to %lx\n", cpu, core99_l3_cache);
-        }
-}
-
-/*
- * Set and clear IPIs for powersurge.
- */
-static inline void psurge_set_ipi(int cpu)
-{
-        if (psurge_type == PSURGE_NONE)
-                return;
-        if (cpu == 0)
-                in_be32(psurge_pri_intr);
-        else if (psurge_type == PSURGE_DUAL)
-                out_8(psurge_sec_intr, 0);
-        else
-                PSURGE_QUAD_OUT(PSURGE_QUAD_IRQ_SET, 1 << cpu);
-}
-
-static inline void psurge_clr_ipi(int cpu)
-{
-        if (cpu > 0) {
-                switch(psurge_type) {
-                case PSURGE_DUAL:
-                        out_8(psurge_sec_intr, ~0);
-                case PSURGE_NONE:
-                        break;
-                default:
-                        PSURGE_QUAD_OUT(PSURGE_QUAD_IRQ_CLR, 1 << cpu);
-                }
-        }
-}
-
-/*
- * On powersurge (old SMP powermac architecture) we don't have
- * separate IPIs for separate messages like openpic does.  Instead
- * we have a bitmap for each processor, where a 1 bit means that
- * the corresponding message is pending for that processor.
- * Ideally each cpu's entry would be in a different cache line.
- *  -- paulus.
- */
-static unsigned long psurge_smp_message[NR_CPUS];
-
-void psurge_smp_message_recv(struct pt_regs *regs)
-{
-        int cpu = smp_processor_id();
-        int msg;
-
-        /* clear interrupt */
-        psurge_clr_ipi(cpu);
-
-        if (num_online_cpus() < 2)
-                return;
-
-        /* make sure there is a message there */
-        for (msg = 0; msg < 4; msg++)
-                if (test_and_clear_bit(msg, &psurge_smp_message[cpu]))
-                        smp_message_recv(msg, regs);
-}
-
-irqreturn_t psurge_primary_intr(int irq, void *d, struct pt_regs *regs)
-{
-        psurge_smp_message_recv(regs);
-        return IRQ_HANDLED;
-}
-
-static void smp_psurge_message_pass(int target, int msg)
-{
-        int i;
-
-        if (num_online_cpus() < 2)
-                return;
-
-        for (i = 0; i < NR_CPUS; i++) {
-                if (!cpu_online(i))
-                        continue;
-                if (target == MSG_ALL
-                    || (target == MSG_ALL_BUT_SELF && i != smp_processor_id())
-                    || target == i) {
-                        set_bit(msg, &psurge_smp_message[i]);
-                        psurge_set_ipi(i);
-                }
-        }
-}
-
-/*
- * Determine a quad card presence. We read the board ID register, we
- * force the data bus to change to something else, and we read it again.
- * It it's stable, then the register probably exist (ugh !)
- */
-static int __init psurge_quad_probe(void)
-{
-        int type;
-        unsigned int i;
-
-        type = PSURGE_QUAD_IN(PSURGE_QUAD_BOARD_ID);
-        if (type < PSURGE_QUAD_OKEE || type > PSURGE_QUAD_ICEGRASS
-            || type != PSURGE_QUAD_IN(PSURGE_QUAD_BOARD_ID))
-                return PSURGE_DUAL;
-
-        /* looks OK, try a slightly more rigorous test */
-        /* bogus is not necessarily cacheline-aligned,
-           though I don't suppose that really matters.  -- paulus */
-        for (i = 0; i < 100; i++) {
-                volatile u32 bogus[8];
-                bogus[(0+i)%8] = 0x00000000;
-                bogus[(1+i)%8] = 0x55555555;
-                bogus[(2+i)%8] = 0xFFFFFFFF;
-                bogus[(3+i)%8] = 0xAAAAAAAA;
-                bogus[(4+i)%8] = 0x33333333;
-                bogus[(5+i)%8] = 0xCCCCCCCC;
-                bogus[(6+i)%8] = 0xCCCCCCCC;
-                bogus[(7+i)%8] = 0x33333333;
-                wmb();
-                asm volatile("dcbf 0,%0" : : "r" (bogus) : "memory");
-                mb();
-                if (type != PSURGE_QUAD_IN(PSURGE_QUAD_BOARD_ID))
-                        return PSURGE_DUAL;
-        }
-        return type;
-}
-
-static void __init psurge_quad_init(void)
-{
-        int procbits;
-
-        if (ppc_md.progress) ppc_md.progress("psurge_quad_init", 0x351);
-        procbits = ~PSURGE_QUAD_IN(PSURGE_QUAD_WHICH_CPU);
-        if (psurge_type == PSURGE_QUAD_ICEGRASS)
-                PSURGE_QUAD_BIS(PSURGE_QUAD_RESET_CTL, procbits);
-        else
-                PSURGE_QUAD_BIC(PSURGE_QUAD_CKSTOP_CTL, procbits);
-        mdelay(33);
-        out_8(psurge_sec_intr, ~0);
-        PSURGE_QUAD_OUT(PSURGE_QUAD_IRQ_CLR, procbits);
-        PSURGE_QUAD_BIS(PSURGE_QUAD_RESET_CTL, procbits);
-        if (psurge_type != PSURGE_QUAD_ICEGRASS)
-                PSURGE_QUAD_BIS(PSURGE_QUAD_CKSTOP_CTL, procbits);
-        PSURGE_QUAD_BIC(PSURGE_QUAD_PRIMARY_ARB, procbits);
-        mdelay(33);
-        PSURGE_QUAD_BIC(PSURGE_QUAD_RESET_CTL, procbits);
-        mdelay(33);
-        PSURGE_QUAD_BIS(PSURGE_QUAD_PRIMARY_ARB, procbits);
-        mdelay(33);
-}
-
-static int __init smp_psurge_probe(void)
-{
-        int i, ncpus;
-
-        /* We don't do SMP on the PPC601 -- paulus */
-        if (PVR_VER(mfspr(SPRN_PVR)) == 1)
-                return 1;
-
-        /*
-         * The powersurge cpu board can be used in the generation
-         * of powermacs that have a socket for an upgradeable cpu card,
-         * including the 7500, 8500, 9500, 9600.
-         * The device tree doesn't tell you if you have 2 cpus because
-         * OF doesn't know anything about the 2nd processor.
-         * Instead we look for magic bits in magic registers,
-         * in the hammerhead memory controller in the case of the
-         * dual-cpu powersurge board.  -- paulus.
-         */
-        if (find_devices("hammerhead") == NULL)
-                return 1;
-
-        hhead_base = ioremap(HAMMERHEAD_BASE, 0x800);
-        quad_base = ioremap(PSURGE_QUAD_REG_ADDR, 1024);
-        psurge_sec_intr = hhead_base + HHEAD_SEC_INTR;
-
-        psurge_type = psurge_quad_probe();
-        if (psurge_type != PSURGE_DUAL) {
-                psurge_quad_init();
-                /* All released cards using this HW design have 4 CPUs */
-                ncpus = 4;
-        } else {
-                iounmap(quad_base);
-                if ((in_8(hhead_base + HHEAD_CONFIG) & 0x02) == 0) {
-                        /* not a dual-cpu card */
-                        iounmap(hhead_base);
-                        psurge_type = PSURGE_NONE;
-                        return 1;
-                }
-                ncpus = 2;
-        }
-
-        psurge_start = ioremap(PSURGE_START, 4);
-        psurge_pri_intr = ioremap(PSURGE_PRI_INTR, 4);
-
-        /* this is not actually strictly necessary -- paulus. */
-        for (i = 1; i < ncpus; ++i)
-                smp_hw_index[i] = i;
-
-        if (ppc_md.progress) ppc_md.progress("smp_psurge_probe - done", 0x352);
-
-        return ncpus;
-}
-
-static void __init smp_psurge_kick_cpu(int nr)
-{
-        unsigned long start = __pa(__secondary_start_pmac_0) + nr * 8;
-        unsigned long a;
-
-        /* may need to flush here if secondary bats aren't setup */
-        for (a = KERNELBASE; a < KERNELBASE + 0x800000; a += 32)
-                asm volatile("dcbf 0,%0" : : "r" (a) : "memory");
-        asm volatile("sync");
-
-        if (ppc_md.progress) ppc_md.progress("smp_psurge_kick_cpu", 0x353);
-
-        out_be32(psurge_start, start);
-        mb();
-
-        psurge_set_ipi(nr);
-        udelay(10);
-        psurge_clr_ipi(nr);
-
-        if (ppc_md.progress) ppc_md.progress("smp_psurge_kick_cpu - done", 0x354);
-}
-
-/*
- * With the dual-cpu powersurge board, the decrementers and timebases
- * of both cpus are frozen after the secondary cpu is started up,
- * until we give the secondary cpu another interrupt.  This routine
- * uses this to get the timebases synchronized.
- *  -- paulus.
- */
-static void __init psurge_dual_sync_tb(int cpu_nr)
-{
-        int t;
-
-        set_dec(tb_ticks_per_jiffy);
-        set_tb(0, 0);
-        last_jiffy_stamp(cpu_nr) = 0;
-
-        if (cpu_nr > 0) {
-                mb();
-                sec_tb_reset = 1;
-                return;
-        }
-
-        /* wait for the secondary to have reset its TB before proceeding */
-        for (t = 10000000; t > 0 && !sec_tb_reset; --t)
-                ;
-
-        /* now interrupt the secondary, starting both TBs */
-        psurge_set_ipi(1);
-
-        smp_tb_synchronized = 1;
-}
-
-static struct irqaction psurge_irqaction = {
-        .handler = psurge_primary_intr,
-        .flags = SA_INTERRUPT,
-        .mask = CPU_MASK_NONE,
-        .name = "primary IPI",
-};
-
-static void __init smp_psurge_setup_cpu(int cpu_nr)
-{
-
-        if (cpu_nr == 0) {
-                /* If we failed to start the second CPU, we should still
-                 * send it an IPI to start the timebase & DEC or we might
-                 * have them stuck.
-                 */
-                if (num_online_cpus() < 2) {
-                        if (psurge_type == PSURGE_DUAL)
-                                psurge_set_ipi(1);
-                        return;
-                }
-                /* reset the entry point so if we get another intr we won't
-                 * try to startup again */
-                out_be32(psurge_start, 0x100);
-                if (setup_irq(30, &psurge_irqaction))
-                        printk(KERN_ERR "Couldn't get primary IPI interrupt");
-        }
-
-        if (psurge_type == PSURGE_DUAL)
-                psurge_dual_sync_tb(cpu_nr);
-}
-
-void __init smp_psurge_take_timebase(void)
-{
-        /* Dummy implementation */
-}
-
-void __init smp_psurge_give_timebase(void)
-{
-        /* Dummy implementation */
-}
-
-static int __init smp_core99_probe(void)
-{
-#ifdef CONFIG_6xx
-        extern int powersave_nap;
-#endif
-        struct device_node *cpus, *firstcpu;
-        int i, ncpus = 0, boot_cpu = -1;
-        u32 *tbprop = NULL;
-
-        if (ppc_md.progress) ppc_md.progress("smp_core99_probe", 0x345);
-        cpus = firstcpu = find_type_devices("cpu");
-        while(cpus != NULL) {
-                u32 *regprop = (u32 *)get_property(cpus, "reg", NULL);
-                char *stateprop = (char *)get_property(cpus, "state", NULL);
-                if (regprop != NULL && stateprop != NULL &&
-                    !strncmp(stateprop, "running", 7))
-                        boot_cpu = *regprop;
-                ++ncpus;
-                cpus = cpus->next;
-        }
-        if (boot_cpu == -1)
-                printk(KERN_WARNING "Couldn't detect boot CPU !\n");
-        if (boot_cpu != 0)
-                printk(KERN_WARNING "Boot CPU is %d, unsupported setup !\n", boot_cpu);
-
-        if (machine_is_compatible("MacRISC4")) {
-                extern struct smp_ops_t core99_smp_ops;
-
-                core99_smp_ops.take_timebase = smp_generic_take_timebase;
-                core99_smp_ops.give_timebase = smp_generic_give_timebase;
-        } else {
-                if (firstcpu != NULL)
-                        tbprop = (u32 *)get_property(firstcpu, "timebase-enable", NULL);
-                if (tbprop)
-                        core99_tb_gpio = *tbprop;
-                else
-                        core99_tb_gpio = KL_GPIO_TB_ENABLE;
-        }
-
-        if (ncpus > 1) {
-                openpic_request_IPIs();
-                for (i = 1; i < ncpus; ++i)
-                        smp_hw_index[i] = i;
-#ifdef CONFIG_6xx
-                powersave_nap = 0;
-#endif
-                core99_init_caches(0);
-        }
-
-        return ncpus;
-}
-
-static void __devinit smp_core99_kick_cpu(int nr)
-{
-        unsigned long save_vector, new_vector;
-        unsigned long flags;
-
-        volatile unsigned long *vector
-                 = ((volatile unsigned long *)(KERNELBASE+0x100));
-        if (nr < 0 || nr > 3)
-                return;
-        if (ppc_md.progress) ppc_md.progress("smp_core99_kick_cpu", 0x346);
-
-        local_irq_save(flags);
-        local_irq_disable();
-
-        /* Save reset vector */
-        save_vector = *vector;
-
-        /* Setup fake reset vector that does    
-         *   b __secondary_start_pmac_0 + nr*8 - KERNELBASE
-         */
-        new_vector = (unsigned long) __secondary_start_pmac_0 + nr * 8;
-        *vector = 0x48000002 + new_vector - KERNELBASE;
-
-        /* flush data cache and inval instruction cache */
-        flush_icache_range((unsigned long) vector, (unsigned long) vector + 4);
-
-        /* Put some life in our friend */
-        pmac_call_feature(PMAC_FTR_RESET_CPU, NULL, nr, 0);
-
-        /* FIXME: We wait a bit for the CPU to take the exception, I should
-         * instead wait for the entry code to set something for me. Well,
-         * ideally, all that crap will be done in prom.c and the CPU left
-         * in a RAM-based wait loop like CHRP.
-         */
-        mdelay(1);
-
-        /* Restore our exception vector */
-        *vector = save_vector;
-        flush_icache_range((unsigned long) vector, (unsigned long) vector + 4);
-
-        local_irq_restore(flags);
-        if (ppc_md.progress) ppc_md.progress("smp_core99_kick_cpu done", 0x347);
-}
-
-static void __devinit smp_core99_setup_cpu(int cpu_nr)
-{
-        /* Setup L2/L3 */
-        if (cpu_nr != 0)
-                core99_init_caches(cpu_nr);
-
-        /* Setup openpic */
-        do_openpic_setup_cpu();
-
-        if (cpu_nr == 0) {
-#ifdef CONFIG_POWER4
-                extern void g5_phy_disable_cpu1(void);
-
-                /* If we didn't start the second CPU, we must take
-                 * it off the bus
-                 */
-                if (machine_is_compatible("MacRISC4") &&
-                    num_online_cpus() < 2)              
-                        g5_phy_disable_cpu1();
-#endif /* CONFIG_POWER4 */
-                if (ppc_md.progress) ppc_md.progress("core99_setup_cpu 0 done", 0x349);
-        }
-}
-
-/* not __init, called in sleep/wakeup code */
-void smp_core99_take_timebase(void)
-{
-        unsigned long flags;
-
-        /* tell the primary we're here */
-        sec_tb_reset = 1;
-        mb();
-
-        /* wait for the primary to set pri_tb_hi/lo */
-        while (sec_tb_reset < 2)
-                mb();
-
-        /* set our stuff the same as the primary */
-        local_irq_save(flags);
-        set_dec(1);
-        set_tb(pri_tb_hi, pri_tb_lo);
-        last_jiffy_stamp(smp_processor_id()) = pri_tb_stamp;
-        mb();
-
-        /* tell the primary we're done */
-        sec_tb_reset = 0;
-        mb();
-        local_irq_restore(flags);
-}
-
-/* not __init, called in sleep/wakeup code */
-void smp_core99_give_timebase(void)
-{
-        unsigned long flags;
-        unsigned int t;
-
-        /* wait for the secondary to be in take_timebase */
-        for (t = 100000; t > 0 && !sec_tb_reset; --t)
-                udelay(10);
-        if (!sec_tb_reset) {
-                printk(KERN_WARNING "Timeout waiting sync on second CPU\n");
-                return;
-        }
-
-        /* freeze the timebase and read it */
-        /* disable interrupts so the timebase is disabled for the
-           shortest possible time */
-        local_irq_save(flags);
-        pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, core99_tb_gpio, 4);
-        pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, core99_tb_gpio, 0);
-        mb();
-        pri_tb_hi = get_tbu();
-        pri_tb_lo = get_tbl();
-        pri_tb_stamp = last_jiffy_stamp(smp_processor_id());
-        mb();
-
-        /* tell the secondary we're ready */
-        sec_tb_reset = 2;
-        mb();
-
-        /* wait for the secondary to have taken it */
-        for (t = 100000; t > 0 && sec_tb_reset; --t)
-                udelay(10);
-        if (sec_tb_reset)
-                printk(KERN_WARNING "Timeout waiting sync(2) on second CPU\n");
-        else
-                smp_tb_synchronized = 1;
-
-        /* Now, restart the timebase by leaving the GPIO to an open collector */
-        pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, core99_tb_gpio, 0);
-        pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, core99_tb_gpio, 0);
-        local_irq_restore(flags);
-}
-
-
-/* PowerSurge-style Macs */
-struct smp_ops_t psurge_smp_ops = {
-        .message_pass   = smp_psurge_message_pass,
-        .probe          = smp_psurge_probe,
-        .kick_cpu       = smp_psurge_kick_cpu,
-        .setup_cpu      = smp_psurge_setup_cpu,
-        .give_timebase  = smp_psurge_give_timebase,
-        .take_timebase  = smp_psurge_take_timebase,
-};
-
-/* Core99 Macs (dual G4s) */
-struct smp_ops_t core99_smp_ops = {
-        .message_pass   = smp_openpic_message_pass,
-        .probe          = smp_core99_probe,
-        .kick_cpu       = smp_core99_kick_cpu,
-        .setup_cpu      = smp_core99_setup_cpu,
-        .give_timebase  = smp_core99_give_timebase,
-        .take_timebase  = smp_core99_take_timebase,
-};
-
-#ifdef CONFIG_HOTPLUG_CPU
-
-int __cpu_disable(void)
-{
-        cpu_clear(smp_processor_id(), cpu_online_map);
-
-        /* XXX reset cpu affinity here */
-        openpic_set_priority(0xf);
-        asm volatile("mtdec %0" : : "r" (0x7fffffff));
-        mb();
-        udelay(20);
-        asm volatile("mtdec %0" : : "r" (0x7fffffff));
-        return 0;
-}
-
-extern void low_cpu_die(void) __attribute__((noreturn)); /* in pmac_sleep.S */
-static int cpu_dead[NR_CPUS];
-
-void cpu_die(void)
-{
-        local_irq_disable();
-        cpu_dead[smp_processor_id()] = 1;
-        mb();
-        low_cpu_die();
-}
-
-void __cpu_die(unsigned int cpu)
-{
-        int timeout;
-
-        timeout = 1000;
-        while (!cpu_dead[cpu]) {
-                if (--timeout == 0) {
-                        printk("CPU %u refused to die!\n", cpu);
-                        break;
-                }
-                msleep(1);
-        }
-        cpu_callin_map[cpu] = 0;
-        cpu_dead[cpu] = 0;
-}
-
-#endif
diff --git a/arch/ppc/platforms/pmac_time.c b/arch/ppc/platforms/pmac_time.c
deleted file mode 100644
index edb9fcc64790..000000000000
--- a/arch/ppc/platforms/pmac_time.c
+++ /dev/null
@@ -1,291 +0,0 @@
-/*
- * Support for periodic interrupts (100 per second) and for getting
- * the current time from the RTC on Power Macintoshes.
- *
- * We use the decrementer register for our periodic interrupts.
- *
- * Paul Mackerras       August 1996.
- * Copyright (C) 1996 Paul Mackerras.
- */
-#include <linux/config.h>
-#include <linux/errno.h>
-#include <linux/sched.h>
-#include <linux/kernel.h>
-#include <linux/param.h>
-#include <linux/string.h>
-#include <linux/mm.h>
-#include <linux/init.h>
-#include <linux/time.h>
-#include <linux/adb.h>
-#include <linux/cuda.h>
-#include <linux/pmu.h>
-#include <linux/hardirq.h>
-
-#include <asm/sections.h>
-#include <asm/prom.h>
-#include <asm/system.h>
-#include <asm/io.h>
-#include <asm/pgtable.h>
-#include <asm/machdep.h>
-#include <asm/time.h>
-#include <asm/nvram.h>
-
-/* Apparently the RTC stores seconds since 1 Jan 1904 */
-#define RTC_OFFSET      2082844800
-
-/*
- * Calibrate the decrementer frequency with the VIA timer 1.
- */
-#define VIA_TIMER_FREQ_6        4700000 /* time 1 frequency * 6 */
-
-/* VIA registers */
-#define RS              0x200           /* skip between registers */
-#define T1CL            (4*RS)          /* Timer 1 ctr/latch (low 8 bits) */
-#define T1CH            (5*RS)          /* Timer 1 counter (high 8 bits) */
-#define T1LL            (6*RS)          /* Timer 1 latch (low 8 bits) */
-#define T1LH            (7*RS)          /* Timer 1 latch (high 8 bits) */
-#define ACR             (11*RS)         /* Auxiliary control register */
-#define IFR             (13*RS)         /* Interrupt flag register */
-
-/* Bits in ACR */
-#define T1MODE          0xc0            /* Timer 1 mode */
-#define T1MODE_CONT     0x40            /*  continuous interrupts */
-
-/* Bits in IFR and IER */
-#define T1_INT          0x40            /* Timer 1 interrupt */
-
-extern struct timezone sys_tz;
-
-long __init
-pmac_time_init(void)
-{
-#ifdef CONFIG_NVRAM
-        s32 delta = 0;
-        int dst;
-        
-        delta = ((s32)pmac_xpram_read(PMAC_XPRAM_MACHINE_LOC + 0x9)) << 16;
-        delta |= ((s32)pmac_xpram_read(PMAC_XPRAM_MACHINE_LOC + 0xa)) << 8;
-        delta |= pmac_xpram_read(PMAC_XPRAM_MACHINE_LOC + 0xb);
-        if (delta & 0x00800000UL)
-                delta |= 0xFF000000UL;
-        dst = ((pmac_xpram_read(PMAC_XPRAM_MACHINE_LOC + 0x8) & 0x80) != 0);
-        printk("GMT Delta read from XPRAM: %d minutes, DST: %s\n", delta/60,
-                dst ? "on" : "off");
-        return delta;
-#else
-        return 0;
-#endif
-}
-
-unsigned long
-pmac_get_rtc_time(void)
-{
-#if defined(CONFIG_ADB_CUDA) || defined(CONFIG_ADB_PMU)
-        struct adb_request req;
-        unsigned long now;
-#endif
-
-        /* Get the time from the RTC */
-        switch (sys_ctrler) {
-#ifdef CONFIG_ADB_CUDA
-        case SYS_CTRLER_CUDA:
-                if (cuda_request(&req, NULL, 2, CUDA_PACKET, CUDA_GET_TIME) < 0)
-                        return 0;
-                while (!req.complete)
-                        cuda_poll();
-                if (req.reply_len != 7)
-                        printk(KERN_ERR "pmac_get_rtc_time: got %d byte reply\n",
-                               req.reply_len);
-                now = (req.reply[3] << 24) + (req.reply[4] << 16)
-                        + (req.reply[5] << 8) + req.reply[6];
-                return now - RTC_OFFSET;
-#endif /* CONFIG_ADB_CUDA */
-#ifdef CONFIG_ADB_PMU
-        case SYS_CTRLER_PMU:
-                if (pmu_request(&req, NULL, 1, PMU_READ_RTC) < 0)
-                        return 0;
-                while (!req.complete)
-                        pmu_poll();
-                if (req.reply_len != 4)
-                        printk(KERN_ERR "pmac_get_rtc_time: got %d byte reply\n",
-                               req.reply_len);
-                now = (req.reply[0] << 24) + (req.reply[1] << 16)
-                        + (req.reply[2] << 8) + req.reply[3];
-                return now - RTC_OFFSET;
-#endif /* CONFIG_ADB_PMU */
-        default: ;
-        }
-        return 0;
-}
-
-int
-pmac_set_rtc_time(unsigned long nowtime)
-{
-#if defined(CONFIG_ADB_CUDA) || defined(CONFIG_ADB_PMU)
-        struct adb_request req;
-#endif
-
-        nowtime += RTC_OFFSET;
-
-        switch (sys_ctrler) {
-#ifdef CONFIG_ADB_CUDA
-        case SYS_CTRLER_CUDA:
-                if (cuda_request(&req, NULL, 6, CUDA_PACKET, CUDA_SET_TIME,
-                                 nowtime >> 24, nowtime >> 16, nowtime >> 8, nowtime) < 0)
-                        return 0;
-                while (!req.complete)
-                        cuda_poll();
-                if ((req.reply_len != 3) && (req.reply_len != 7))
-                        printk(KERN_ERR "pmac_set_rtc_time: got %d byte reply\n",
-                               req.reply_len);
-                return 1;
-#endif /* CONFIG_ADB_CUDA */
-#ifdef CONFIG_ADB_PMU
-        case SYS_CTRLER_PMU:
-                if (pmu_request(&req, NULL, 5, PMU_SET_RTC,
-                                nowtime >> 24, nowtime >> 16, nowtime >> 8, nowtime) < 0)
-                        return 0;
-                while (!req.complete)
-                        pmu_poll();
-                if (req.reply_len != 0)
-                        printk(KERN_ERR "pmac_set_rtc_time: got %d byte reply\n",
-                               req.reply_len);
-                return 1;
-#endif /* CONFIG_ADB_PMU */
-        default:
-                return 0;
-        }
-}
-
-/*
- * Calibrate the decrementer register using VIA timer 1.
- * This is used both on powermacs and CHRP machines.
- */
-int __init
-via_calibrate_decr(void)
-{
-        struct device_node *vias;
-        volatile unsigned char __iomem *via;
-        int count = VIA_TIMER_FREQ_6 / 100;
-        unsigned int dstart, dend;
-
-        vias = find_devices("via-cuda");
-        if (vias == 0)
-                vias = find_devices("via-pmu");
-        if (vias == 0)
-                vias = find_devices("via");
-        if (vias == 0 || vias->n_addrs == 0)
-                return 0;
-        via = ioremap(vias->addrs[0].address, vias->addrs[0].size);
-
-        /* set timer 1 for continuous interrupts */
-        out_8(&via[ACR], (via[ACR] & ~T1MODE) | T1MODE_CONT);
-        /* set the counter to a small value */
-        out_8(&via[T1CH], 2);
-        /* set the latch to `count' */
-        out_8(&via[T1LL], count);
-        out_8(&via[T1LH], count >> 8);
-        /* wait until it hits 0 */
-        while ((in_8(&via[IFR]) & T1_INT) == 0)
-                ;
-        dstart = get_dec();
-        /* clear the interrupt & wait until it hits 0 again */
-        in_8(&via[T1CL]);
-        while ((in_8(&via[IFR]) & T1_INT) == 0)
-                ;
-        dend = get_dec();
-
-        tb_ticks_per_jiffy = (dstart - dend) / ((6 * HZ)/100);
-        tb_to_us = mulhwu_scale_factor(dstart - dend, 60000);
-
-        printk(KERN_INFO "via_calibrate_decr: ticks per jiffy = %u (%u ticks)\n",
-               tb_ticks_per_jiffy, dstart - dend);
-
-        iounmap(via);
-        
-        return 1;
-}
-
-#ifdef CONFIG_PM
-/*
- * Reset the time after a sleep.
- */
-static int
-time_sleep_notify(struct pmu_sleep_notifier *self, int when)
-{
-        static unsigned long time_diff;
-        unsigned long flags;
-        unsigned long seq;
-
-        switch (when) {
-        case PBOOK_SLEEP_NOW:
-                do {
-                        seq = read_seqbegin_irqsave(&xtime_lock, flags);
-                        time_diff = xtime.tv_sec - pmac_get_rtc_time();
-                } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
-                break;
-        case PBOOK_WAKE:
-                write_seqlock_irqsave(&xtime_lock, flags);
-                xtime.tv_sec = pmac_get_rtc_time() + time_diff;
-                xtime.tv_nsec = 0;
-                last_rtc_update = xtime.tv_sec;
-                write_sequnlock_irqrestore(&xtime_lock, flags);
-                break;
-        }
-        return PBOOK_SLEEP_OK;
-}
-
-static struct pmu_sleep_notifier time_sleep_notifier = {
-        time_sleep_notify, SLEEP_LEVEL_MISC,
-};
-#endif /* CONFIG_PM */
-
-/*
- * Query the OF and get the decr frequency.
- * This was taken from the pmac time_init() when merging the prep/pmac
- * time functions.
- */
-void __init
-pmac_calibrate_decr(void)
-{
-        struct device_node *cpu;
-        unsigned int freq, *fp;
-
-#ifdef CONFIG_PM
-        pmu_register_sleep_notifier(&time_sleep_notifier);
-#endif /* CONFIG_PM */
-
-        /* We assume MacRISC2 machines have correct device-tree
-         * calibration. That's better since the VIA itself seems
-         * to be slightly off. --BenH
-         */
-        if (!machine_is_compatible("MacRISC2") &&
-            !machine_is_compatible("MacRISC3") &&
-            !machine_is_compatible("MacRISC4"))
-                if (via_calibrate_decr())
-                        return;
-
-        /* Special case: QuickSilver G4s seem to have a badly calibrated
-         * timebase-frequency in OF, VIA is much better on these. We should
-         * probably implement calibration based on the KL timer on these
-         * machines anyway... -BenH
-         */
-        if (machine_is_compatible("PowerMac3,5"))
-                if (via_calibrate_decr())
-                        return;
-        /*
-         * The cpu node should have a timebase-frequency property
-         * to tell us the rate at which the decrementer counts.
-         */
-        cpu = find_type_devices("cpu");
-        if (cpu == 0)
-                panic("can't find cpu node in time_init");
-        fp = (unsigned int *) get_property(cpu, "timebase-frequency", NULL);
-        if (fp == 0)
-                panic("can't get cpu timebase frequency");
-        freq = *fp;
-        printk("time_init: decrementer frequency = %u.%.6u MHz\n",
-               freq/1000000, freq%1000000);
-        tb_ticks_per_jiffy = freq / HZ;
-        tb_to_us = mulhwu_scale_factor(freq, 1000000);
-}
diff --git a/arch/ppc/syslib/Makefile b/arch/ppc/syslib/Makefile
index 84ef03018d0e..159dcd92a6d1 100644
--- a/arch/ppc/syslib/Makefile
+++ b/arch/ppc/syslib/Makefile
@@ -39,8 +39,6 @@ obj-$(CONFIG_8xx)		+= m8xx_setup.o ppc8xx_pic.o $(wdt-mpc8xx-y) \
                                    ppc_sys.o mpc8xx_devices.o mpc8xx_sys.o
 obj-$(CONFIG_PCI_QSPAN)         += qspan_pci.o
 obj-$(CONFIG_PPC_OF)            += prom_init.o prom.o
-obj-$(CONFIG_PPC_PMAC)          += open_pic.o
-obj-$(CONFIG_POWER4)            += open_pic2.o
 obj-$(CONFIG_PPC_CHRP)          += open_pic.o
 obj-$(CONFIG_PPC_PREP)          += open_pic.o todc_time.o
 obj-$(CONFIG_BAMBOO)            += pci_auto.o todc_time.o
diff --git a/arch/ppc/syslib/mpc83xx_devices.c b/arch/ppc/syslib/mpc83xx_devices.c
index 847df4409982..f9b95de70e23 100644
--- a/arch/ppc/syslib/mpc83xx_devices.c
+++ b/arch/ppc/syslib/mpc83xx_devices.c
@@ -28,7 +28,6 @@
  */
 
 struct gianfar_mdio_data mpc83xx_mdio_pdata = {
-        .paddr = 0x24520,
 };
 
 static struct gianfar_platform_data mpc83xx_tsec1_pdata = {
@@ -226,7 +225,14 @@ struct platform_device ppc_sys_platform_devices[] = {
                 .name = "fsl-gianfar_mdio",
                 .id = 0,
                 .dev.platform_data = &mpc83xx_mdio_pdata,
-                .num_resources = 0,
+                .num_resources = 1,
+                .resource = (struct resource[]) {
+                        {
+                                .start  = 0x24520,
+                                .end    = 0x2453f,
+                                .flags  = IORESOURCE_MEM,
+                        },
+                },
         },
 };
 
diff --git a/arch/ppc/syslib/mpc85xx_devices.c b/arch/ppc/syslib/mpc85xx_devices.c
index 69949d255658..00e9b6ff2f6e 100644
--- a/arch/ppc/syslib/mpc85xx_devices.c
+++ b/arch/ppc/syslib/mpc85xx_devices.c
@@ -26,7 +26,6 @@
  * what CCSRBAR is, will get fixed up by mach_mpc85xx_fixup
  */
 struct gianfar_mdio_data mpc85xx_mdio_pdata = {
-        .paddr = MPC85xx_MIIM_OFFSET,
 };
 
 static struct gianfar_platform_data mpc85xx_tsec1_pdata = {
@@ -720,7 +719,14 @@ struct platform_device ppc_sys_platform_devices[] = {
                 .name = "fsl-gianfar_mdio",
                 .id = 0,
                 .dev.platform_data = &mpc85xx_mdio_pdata,
-                .num_resources = 0,
+                .num_resources = 1,
+                .resource = (struct resource[]) {
+                        {
+                                .start  = 0x24520,
+                                .end    = 0x2453f,
+                                .flags  = IORESOURCE_MEM,
+                        },
+                },
         },
 };
 
diff --git a/arch/ppc/syslib/ocp.c b/arch/ppc/syslib/ocp.c
index 9ccce438bd7a..ab34b1d6072f 100644
--- a/arch/ppc/syslib/ocp.c
+++ b/arch/ppc/syslib/ocp.c
@@ -189,6 +189,8 @@ ocp_device_resume(struct device *dev)
 struct bus_type ocp_bus_type = {
         .name = "ocp",
         .match = ocp_device_match,
+        .probe = ocp_driver_probe,
+        .remove = ocp_driver_remove,
         .suspend = ocp_device_suspend,
         .resume = ocp_device_resume,
 };
@@ -210,8 +212,6 @@ ocp_register_driver(struct ocp_driver *drv)
         /* initialize common driver fields */
         drv->driver.name = drv->name;
         drv->driver.bus = &ocp_bus_type;
-        drv->driver.probe = ocp_device_probe;
-        drv->driver.remove = ocp_device_remove;
 
         /* register with core */
         return driver_register(&drv->driver);
diff --git a/arch/ppc/syslib/prom.c b/arch/ppc/syslib/prom.c
index af4deace49e0..482f837fd373 100644
--- a/arch/ppc/syslib/prom.c
+++ b/arch/ppc/syslib/prom.c
@@ -70,8 +70,6 @@ int use_of_interrupt_tree;
 struct device_node *dflt_interrupt_controller;
 int num_interrupt_controllers;
 
-int pmac_newworld;
-
 extern unsigned int rtas_entry;  /* physical pointer */
 
 extern struct device_node *allnodes;
@@ -123,22 +121,13 @@ finish_device_tree(void)
         unsigned long mem = (unsigned long) klimit;
         struct device_node *np;
 
-        /* All newworld pmac machines and CHRPs now use the interrupt tree */
+        /* All CHRPs now use the interrupt tree */
         for (np = allnodes; np != NULL; np = np->allnext) {
                 if (get_property(np, "interrupt-parent", NULL)) {
                         use_of_interrupt_tree = 1;
                         break;
                 }
         }
-        if (_machine == _MACH_Pmac && use_of_interrupt_tree)
-                pmac_newworld = 1;
-
-#ifdef CONFIG_BOOTX_TEXT
-        if (boot_infos && pmac_newworld) {
-                prom_print("WARNING ! BootX/miBoot booting is not supported on this machine\n");
-                prom_print("          You should use an Open Firmware bootloader\n");
-        }
-#endif /* CONFIG_BOOTX_TEXT */
 
         if (use_of_interrupt_tree) {
                 /*
@@ -434,16 +423,10 @@ finish_node_interrupts(struct device_node *np, unsigned long mem_start)
                  * those machines, we want to offset interrupts from the
                  * second openpic by 128 -- BenH
                  */
-                if (_machine != _MACH_Pmac && num_interrupt_controllers > 1
+                if (num_interrupt_controllers > 1
                     && ic != NULL
                     && get_property(ic, "interrupt-parent", NULL) == NULL)
                         offset = 16;
-                else if (_machine == _MACH_Pmac && num_interrupt_controllers > 1
-                         && ic != NULL && ic->parent != NULL) {
-                        char *name = get_property(ic->parent, "name", NULL);
-                        if (name && !strcmp(name, "u3"))
-                                offset = 128;
-                }
 
                 np->intrs[i].line = irq[0] + offset;
                 if (n > 1)
diff --git a/arch/ppc/xmon/start.c b/arch/ppc/xmon/start.c
index c80177f8ec04..4344cbe9b5c5 100644
--- a/arch/ppc/xmon/start.c
+++ b/arch/ppc/xmon/start.c
@@ -18,7 +18,6 @@
 #include <asm/bootx.h>
 #include <asm/machdep.h>
 #include <asm/errno.h>
-#include <asm/pmac_feature.h>
 #include <asm/processor.h>
 #include <asm/delay.h>
 #include <asm/btext.h>
@@ -27,11 +26,9 @@ static volatile unsigned char *sccc, *sccd;
 unsigned int TXRDY, RXRDY, DLAB;
 static int xmon_expect(const char *str, unsigned int timeout);
 
-static int use_serial;
 static int use_screen;
 static int via_modem;
 static int xmon_use_sccb;
-static struct device_node *channel_node;
 
 #define TB_SPEED        25000000
 
@@ -112,96 +109,21 @@ xmon_map_scc(void)
 #ifdef CONFIG_PPC_MULTIPLATFORM
         volatile unsigned char *base;
 
-        if (_machine == _MACH_Pmac) {
-                struct device_node *np;
-                unsigned long addr;
-#ifdef CONFIG_BOOTX_TEXT
-                if (!use_screen && !use_serial
-                    && !machine_is_compatible("iMac")) {
-                        /* see if there is a keyboard in the device tree
-                           with a parent of type "adb" */
-                        for (np = find_devices("keyboard"); np; np = np->next)
-                                if (np->parent && np->parent->type
-                                    && strcmp(np->parent->type, "adb") == 0)
-                                        break;
-
-                        /* needs to be hacked if xmon_printk is to be used
-                           from within find_via_pmu() */
-#ifdef CONFIG_ADB_PMU
-                        if (np != NULL && boot_text_mapped && find_via_pmu())
-                                use_screen = 1;
-#endif
-#ifdef CONFIG_ADB_CUDA
-                        if (np != NULL && boot_text_mapped && find_via_cuda())
-                                use_screen = 1;
-#endif
-                }
-                if (!use_screen && (np = find_devices("escc")) != NULL) {
-                        /*
-                         * look for the device node for the serial port
-                         * we're using and see if it says it has a modem
-                         */
-                        char *name = xmon_use_sccb? "ch-b": "ch-a";
-                        char *slots;
-                        int l;
-
-                        np = np->child;
-                        while (np != NULL && strcmp(np->name, name) != 0)
-                                np = np->sibling;
-                        if (np != NULL) {
-                                /* XXX should parse this properly */
-                                channel_node = np;
-                                slots = get_property(np, "slot-names", &l);
-                                if (slots != NULL && l >= 10
-                                    && strcmp(slots+4, "Modem") == 0)
-                                        via_modem = 1;
-                        }
-                }
-                btext_drawstring("xmon uses ");
-                if (use_screen)
-                        btext_drawstring("screen and keyboard\n");
-                else {
-                        if (via_modem)
-                                btext_drawstring("modem on ");
-                        btext_drawstring(xmon_use_sccb? "printer": "modem");
-                        btext_drawstring(" port\n");
-                }
-
-#endif /* CONFIG_BOOTX_TEXT */
-
-#ifdef CHRP_ESCC
-                addr = 0xc1013020;
-#else
-                addr = 0xf3013020;
-#endif
-                TXRDY = 4;
-                RXRDY = 1;
-        
-                np = find_devices("mac-io");
-                if (np && np->n_addrs)
-                        addr = np->addrs[0].address + 0x13020;
-                base = (volatile unsigned char *) ioremap(addr & PAGE_MASK, PAGE_SIZE);
-                sccc = base + (addr & ~PAGE_MASK);
-                sccd = sccc + 0x10;
-
-        }
 #ifdef CONFIG_PPC_CHRP
-        else {
-                base = (volatile unsigned char *) isa_io_base;
-                if (_machine == _MACH_chrp)
-                        base = (volatile unsigned char *)
-                                ioremap(chrp_find_phys_io_base(), 0x1000);
-
-                sccc = base + 0x3fd;
-                sccd = base + 0x3f8;
-                if (xmon_use_sccb) {
-                        sccc -= 0x100;
-                        sccd -= 0x100;
-                }
-                TXRDY = 0x20;
-                RXRDY = 1;
-                DLAB = 0x80;
+        base = (volatile unsigned char *) isa_io_base;
+        if (_machine == _MACH_chrp)
+                base = (volatile unsigned char *)
+                        ioremap(chrp_find_phys_io_base(), 0x1000);
+
+        sccc = base + 0x3fd;
+        sccd = base + 0x3f8;
+        if (xmon_use_sccb) {
+                sccc -= 0x100;
+                sccd -= 0x100;
         }
+        TXRDY = 0x20;
+        RXRDY = 1;
+        DLAB = 0x80;
 #endif /* CONFIG_PPC_CHRP */
 #elif defined(CONFIG_GEMINI)
         /* should already be mapped by the kernel boot */
@@ -385,16 +307,6 @@ xmon_read_poll(void)
         return *sccd;
 }
 
-static unsigned char scc_inittab[] = {
-    13, 0,              /* set baud rate divisor */
-    12, 1,
-    14, 1,              /* baud rate gen enable, src=rtxc */
-    11, 0x50,           /* clocks = br gen */
-    5,  0xea,           /* tx 8 bits, assert DTR & RTS */
-    4,  0x46,           /* x16 clock, 1 stop */
-    3,  0xc1,           /* rx enable, 8 bits */
-};
-
 void
 xmon_init_scc(void)
 {
@@ -407,43 +319,6 @@ xmon_init_scc(void)
                 sccd[3] = 3; eieio();           /* LCR = 8N1 */
                 sccd[1] = 0; eieio();           /* IER = 0 */
         }
-        else if ( _machine == _MACH_Pmac )
-        {
-                int i, x;
-
-                if (channel_node != 0)
-                        pmac_call_feature(
-                                PMAC_FTR_SCC_ENABLE,
-                                channel_node,
-                                PMAC_SCC_ASYNC | PMAC_SCC_FLAG_XMON, 1);
-                        printk(KERN_INFO "Serial port locked ON by debugger !\n");
-                if (via_modem && channel_node != 0) {
-                        unsigned int t0;
-
-                        pmac_call_feature(
-                                PMAC_FTR_MODEM_ENABLE,
-                                channel_node, 0, 1);
-                        printk(KERN_INFO "Modem powered up by debugger !\n");
-                        t0 = readtb();
-                        while (readtb() - t0 < 3*TB_SPEED)
-                                eieio();
-                }
-                /* use the B channel if requested */
-                if (xmon_use_sccb) {
-                        sccc = (volatile unsigned char *)
-                                ((unsigned long)sccc & ~0x20);
-                        sccd = sccc + 0x10;
-                }
-                for (i = 20000; i != 0; --i) {
-                        x = *sccc; eieio();
-                }
-                *sccc = 9; eieio();             /* reset A or B side */
-                *sccc = ((unsigned long)sccc & 0x20)? 0x80: 0x40; eieio();
-                for (i = 0; i < sizeof(scc_inittab); ++i) {
-                        *sccc = scc_inittab[i];
-                        eieio();
-                }
-        }
         scc_initialized = 1;
         if (via_modem) {
                 for (;;) {
@@ -632,19 +507,9 @@ xmon_fgets(char *str, int nb, void *f)
 void
 xmon_enter(void)
 {
-#ifdef CONFIG_ADB_PMU
-        if (_machine == _MACH_Pmac) {
-                pmu_suspend();
-        }
-#endif
 }
 
 void
 xmon_leave(void)
 {
-#ifdef CONFIG_ADB_PMU
-        if (_machine == _MACH_Pmac) {
-                pmu_resume();
-        }
-#endif
 }
diff --git a/arch/ppc/xmon/xmon.c b/arch/ppc/xmon/xmon.c
index 9075a7538e26..bdaf6597b4c2 100644
--- a/arch/ppc/xmon/xmon.c
+++ b/arch/ppc/xmon/xmon.c
@@ -16,9 +16,6 @@
 #include <asm/bootx.h>
 #include <asm/machdep.h>
 #include <asm/xmon.h>
-#ifdef CONFIG_PMAC_BACKLIGHT
-#include <asm/backlight.h>
-#endif
 #include "nonstdio.h"
 #include "privinst.h"
 
@@ -260,16 +257,6 @@ int xmon(struct pt_regs *excp)
          */
 #endif /* CONFIG_SMP */
         remove_bpts();
-#ifdef CONFIG_PMAC_BACKLIGHT
-        if( setjmp(bus_error_jmp) == 0 ) {
-                debugger_fault_handler = handle_fault;
-                sync();
-                set_backlight_enable(1);
-                set_backlight_level(BACKLIGHT_MAX);
-                sync();
-        }
-        debugger_fault_handler = NULL;
-#endif  /* CONFIG_PMAC_BACKLIGHT */
         cmd = cmds(excp);
         if (cmd == 's') {
                 xmon_trace[smp_processor_id()] = SSTEP;
diff --git a/arch/s390/crypto/aes_s390.c b/arch/s390/crypto/aes_s390.c
index 7a1033d8e00f..c5ca2dc5d428 100644
--- a/arch/s390/crypto/aes_s390.c
+++ b/arch/s390/crypto/aes_s390.c
@@ -114,80 +114,108 @@ static unsigned int aes_encrypt_ecb(const struct cipher_desc *desc, u8 *out,
                                     const u8 *in, unsigned int nbytes)
 {
         struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);
+        int ret;
+
+        /* only use complete blocks */
+        nbytes &= ~(AES_BLOCK_SIZE - 1);
 
         switch (sctx->key_len) {
         case 16:
-                crypt_s390_km(KM_AES_128_ENCRYPT, &sctx->key, out, in, nbytes);
+                ret = crypt_s390_km(KM_AES_128_ENCRYPT, &sctx->key, out, in, nbytes);
+                BUG_ON((ret < 0) || (ret != nbytes));
                 break;
         case 24:
-                crypt_s390_km(KM_AES_192_ENCRYPT, &sctx->key, out, in, nbytes);
+                ret = crypt_s390_km(KM_AES_192_ENCRYPT, &sctx->key, out, in, nbytes);
+                BUG_ON((ret < 0) || (ret != nbytes));
                 break;
         case 32:
-                crypt_s390_km(KM_AES_256_ENCRYPT, &sctx->key, out, in, nbytes);
+                ret = crypt_s390_km(KM_AES_256_ENCRYPT, &sctx->key, out, in, nbytes);
+                BUG_ON((ret < 0) || (ret != nbytes));
                 break;
         }
-        return nbytes & ~(AES_BLOCK_SIZE - 1);
+        return nbytes;
 }
 
 static unsigned int aes_decrypt_ecb(const struct cipher_desc *desc, u8 *out,
                                     const u8 *in, unsigned int nbytes)
 {
         struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);
+        int ret;
+
+        /* only use complete blocks */
+        nbytes &= ~(AES_BLOCK_SIZE - 1);
 
         switch (sctx->key_len) {
         case 16:
-                crypt_s390_km(KM_AES_128_DECRYPT, &sctx->key, out, in, nbytes);
+                ret = crypt_s390_km(KM_AES_128_DECRYPT, &sctx->key, out, in, nbytes);
+                BUG_ON((ret < 0) || (ret != nbytes));
                 break;
         case 24:
-                crypt_s390_km(KM_AES_192_DECRYPT, &sctx->key, out, in, nbytes);
+                ret = crypt_s390_km(KM_AES_192_DECRYPT, &sctx->key, out, in, nbytes);
+                BUG_ON((ret < 0) || (ret != nbytes));
                 break;
         case 32:
-                crypt_s390_km(KM_AES_256_DECRYPT, &sctx->key, out, in, nbytes);
+                ret = crypt_s390_km(KM_AES_256_DECRYPT, &sctx->key, out, in, nbytes);
+                BUG_ON((ret < 0) || (ret != nbytes));
                 break;
         }
-        return nbytes & ~(AES_BLOCK_SIZE - 1);
+        return nbytes;
 }
 
 static unsigned int aes_encrypt_cbc(const struct cipher_desc *desc, u8 *out,
                                     const u8 *in, unsigned int nbytes)
 {
         struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);
+        int ret;
+
+        /* only use complete blocks */
+        nbytes &= ~(AES_BLOCK_SIZE - 1);
 
         memcpy(&sctx->iv, desc->info, AES_BLOCK_SIZE);
         switch (sctx->key_len) {
         case 16:
-                crypt_s390_kmc(KMC_AES_128_ENCRYPT, &sctx->iv, out, in, nbytes);
+                ret = crypt_s390_kmc(KMC_AES_128_ENCRYPT, &sctx->iv, out, in, nbytes);
+                BUG_ON((ret < 0) || (ret != nbytes));
                 break;
         case 24:
-                crypt_s390_kmc(KMC_AES_192_ENCRYPT, &sctx->iv, out, in, nbytes);
+                ret = crypt_s390_kmc(KMC_AES_192_ENCRYPT, &sctx->iv, out, in, nbytes);
+                BUG_ON((ret < 0) || (ret != nbytes));
                 break;
         case 32:
-                crypt_s390_kmc(KMC_AES_256_ENCRYPT, &sctx->iv, out, in, nbytes);
+                ret = crypt_s390_kmc(KMC_AES_256_ENCRYPT, &sctx->iv, out, in, nbytes);
+                BUG_ON((ret < 0) || (ret != nbytes));
                 break;
         }
         memcpy(desc->info, &sctx->iv, AES_BLOCK_SIZE);
 
-        return nbytes & ~(AES_BLOCK_SIZE - 1);
+        return nbytes;
 }
 
 static unsigned int aes_decrypt_cbc(const struct cipher_desc *desc, u8 *out,
                                     const u8 *in, unsigned int nbytes)
 {
         struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);
+        int ret;
+
+        /* only use complete blocks */
+        nbytes &= ~(AES_BLOCK_SIZE - 1);
 
         memcpy(&sctx->iv, desc->info, AES_BLOCK_SIZE);
         switch (sctx->key_len) {
         case 16:
-                crypt_s390_kmc(KMC_AES_128_DECRYPT, &sctx->iv, out, in, nbytes);
+                ret = crypt_s390_kmc(KMC_AES_128_DECRYPT, &sctx->iv, out, in, nbytes);
+                BUG_ON((ret < 0) || (ret != nbytes));
                 break;
         case 24:
-                crypt_s390_kmc(KMC_AES_192_DECRYPT, &sctx->iv, out, in, nbytes);
+                ret = crypt_s390_kmc(KMC_AES_192_DECRYPT, &sctx->iv, out, in, nbytes);
+                BUG_ON((ret < 0) || (ret != nbytes));
                 break;
         case 32:
-                crypt_s390_kmc(KMC_AES_256_DECRYPT, &sctx->iv, out, in, nbytes);
+                ret = crypt_s390_kmc(KMC_AES_256_DECRYPT, &sctx->iv, out, in, nbytes);
+                BUG_ON((ret < 0) || (ret != nbytes));
                 break;
         }
-        return nbytes & ~(AES_BLOCK_SIZE - 1);
+        return nbytes;
 }
 
 
diff --git a/arch/s390/crypto/des_s390.c b/arch/s390/crypto/des_s390.c
index a38bb2a3eef6..e3c37aa0a199 100644
--- a/arch/s390/crypto/des_s390.c
+++ b/arch/s390/crypto/des_s390.c
@@ -15,10 +15,8 @@
  */
 #include <linux/init.h>
 #include <linux/module.h>
-#include <linux/mm.h>
-#include <linux/errno.h>
-#include <asm/scatterlist.h>
 #include <linux/crypto.h>
+
 #include "crypt_s390.h"
 #include "crypto_des.h"
 
@@ -46,38 +44,92 @@ struct crypt_s390_des3_192_ctx {
         u8 key[DES3_192_KEY_SIZE];
 };
 
-static int
-des_setkey(void *ctx, const u8 *key, unsigned int keylen, u32 *flags)
+static int des_setkey(void *ctx, const u8 *key, unsigned int keylen,
+                      u32 *flags)
 {
-        struct crypt_s390_des_ctx *dctx;
+        struct crypt_s390_des_ctx *dctx = ctx;
         int ret;
 
-        dctx = ctx;
-        //test if key is valid (not a weak key)
+        /* test if key is valid (not a weak key) */
         ret = crypto_des_check_key(key, keylen, flags);
-        if (ret == 0){
+        if (ret == 0)
                 memcpy(dctx->key, key, keylen);
-        }
         return ret;
 }
 
+static void des_encrypt(void *ctx, u8 *out, const u8 *in)
+{
+        struct crypt_s390_des_ctx *dctx = ctx;
+
+        crypt_s390_km(KM_DEA_ENCRYPT, dctx->key, out, in, DES_BLOCK_SIZE);
+}
+
+static void des_decrypt(void *ctx, u8 *out, const u8 *in)
+{
+        struct crypt_s390_des_ctx *dctx = ctx;
+
+        crypt_s390_km(KM_DEA_DECRYPT, dctx->key, out, in, DES_BLOCK_SIZE);
+}
+
+static unsigned int des_encrypt_ecb(const struct cipher_desc *desc, u8 *out,
+                                    const u8 *in, unsigned int nbytes)
+{
+        struct crypt_s390_des_ctx *sctx = crypto_tfm_ctx(desc->tfm);
+        int ret;
+
+        /* only use complete blocks */
+        nbytes &= ~(DES_BLOCK_SIZE - 1);
+        ret = crypt_s390_km(KM_DEA_ENCRYPT, sctx->key, out, in, nbytes);
+        BUG_ON((ret < 0) || (ret != nbytes));
+
+        return nbytes;
+}
 
-static void
-des_encrypt(void *ctx, u8 *dst, const u8 *src)
+static unsigned int des_decrypt_ecb(const struct cipher_desc *desc, u8 *out,
+                                    const u8 *in, unsigned int nbytes)
 {
-        struct crypt_s390_des_ctx *dctx;
+        struct crypt_s390_des_ctx *sctx = crypto_tfm_ctx(desc->tfm);
+        int ret;
+
+        /* only use complete blocks */
+        nbytes &= ~(DES_BLOCK_SIZE - 1);
+        ret = crypt_s390_km(KM_DEA_DECRYPT, sctx->key, out, in, nbytes);
+        BUG_ON((ret < 0) || (ret != nbytes));
 
-        dctx = ctx;
-        crypt_s390_km(KM_DEA_ENCRYPT, dctx->key, dst, src, DES_BLOCK_SIZE);
+        return nbytes;
 }
 
-static void
-des_decrypt(void *ctx, u8 *dst, const u8 *src)
+static unsigned int des_encrypt_cbc(const struct cipher_desc *desc, u8 *out,
+                                    const u8 *in, unsigned int nbytes)
 {
-        struct crypt_s390_des_ctx *dctx;
+        struct crypt_s390_des_ctx *sctx = crypto_tfm_ctx(desc->tfm);
+        int ret;
 
-        dctx = ctx;
-        crypt_s390_km(KM_DEA_DECRYPT, dctx->key, dst, src, DES_BLOCK_SIZE);
+        /* only use complete blocks */
+        nbytes &= ~(DES_BLOCK_SIZE - 1);
+
+        memcpy(sctx->iv, desc->info, DES_BLOCK_SIZE);
+        ret = crypt_s390_kmc(KMC_DEA_ENCRYPT, &sctx->iv, out, in, nbytes);
+        BUG_ON((ret < 0) || (ret != nbytes));
+
+        memcpy(desc->info, sctx->iv, DES_BLOCK_SIZE);
+        return nbytes;
+}
+
+static unsigned int des_decrypt_cbc(const struct cipher_desc *desc, u8 *out,
+                                    const u8 *in, unsigned int nbytes)
+{
+        struct crypt_s390_des_ctx *sctx = crypto_tfm_ctx(desc->tfm);
+        int ret;
+
+        /* only use complete blocks */
+        nbytes &= ~(DES_BLOCK_SIZE - 1);
+
+        memcpy(&sctx->iv, desc->info, DES_BLOCK_SIZE);
+        ret = crypt_s390_kmc(KMC_DEA_DECRYPT, &sctx->iv, out, in, nbytes);
+        BUG_ON((ret < 0) || (ret != nbytes));
+
+        return nbytes;
 }
 
 static struct crypto_alg des_alg = {
@@ -87,12 +139,19 @@ static struct crypto_alg des_alg = {
         .cra_ctxsize            =       sizeof(struct crypt_s390_des_ctx),
         .cra_module             =       THIS_MODULE,
         .cra_list               =       LIST_HEAD_INIT(des_alg.cra_list),
-        .cra_u                  =       { .cipher = {
-        .cia_min_keysize        =       DES_KEY_SIZE,
-        .cia_max_keysize        =       DES_KEY_SIZE,
-        .cia_setkey             =       des_setkey,
-        .cia_encrypt            =       des_encrypt,
-        .cia_decrypt            =       des_decrypt } }
+        .cra_u                  =       {
+                .cipher = {
+                        .cia_min_keysize        =       DES_KEY_SIZE,
+                        .cia_max_keysize        =       DES_KEY_SIZE,
+                        .cia_setkey             =       des_setkey,
+                        .cia_encrypt            =       des_encrypt,
+                        .cia_decrypt            =       des_decrypt,
+                        .cia_encrypt_ecb        =       des_encrypt_ecb,
+                        .cia_decrypt_ecb        =       des_decrypt_ecb,
+                        .cia_encrypt_cbc        =       des_encrypt_cbc,
+                        .cia_decrypt_cbc        =       des_decrypt_cbc,
+                }
+        }
 };
 
 /*
@@ -107,20 +166,18 @@ static struct crypto_alg des_alg = {
  *   Implementers MUST reject keys that exhibit this property.
  *
  */
-static int
-des3_128_setkey(void *ctx, const u8 *key, unsigned int keylen, u32 *flags)
+static int des3_128_setkey(void *ctx, const u8 *key, unsigned int keylen,
+                           u32 *flags)
 {
         int i, ret;
-        struct crypt_s390_des3_128_ctx *dctx;
+        struct crypt_s390_des3_128_ctx *dctx = ctx;
         const u8* temp_key = key;
 
-        dctx = ctx;
         if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE))) {
-
                 *flags |= CRYPTO_TFM_RES_BAD_KEY_SCHED;
                 return -EINVAL;
         }
-        for (i = 0; i < 2; i++, temp_key += DES_KEY_SIZE) {
+        for (i = 0; i < 2; i++, temp_key += DES_KEY_SIZE) {
                 ret = crypto_des_check_key(temp_key, DES_KEY_SIZE, flags);
                 if (ret < 0)
                         return ret;
@@ -129,24 +186,85 @@ des3_128_setkey(void *ctx, const u8 *key, unsigned int keylen, u32 *flags)
         return 0;
 }
 
-static void
-des3_128_encrypt(void *ctx, u8 *dst, const u8 *src)
+static void des3_128_encrypt(void *ctx, u8 *dst, const u8 *src)
 {
-        struct crypt_s390_des3_128_ctx *dctx;
+        struct crypt_s390_des3_128_ctx *dctx = ctx;
 
-        dctx = ctx;
         crypt_s390_km(KM_TDEA_128_ENCRYPT, dctx->key, dst, (void*)src,
-                        DES3_128_BLOCK_SIZE);
+                      DES3_128_BLOCK_SIZE);
 }
 
-static void
-des3_128_decrypt(void *ctx, u8 *dst, const u8 *src)
+static void des3_128_decrypt(void *ctx, u8 *dst, const u8 *src)
 {
-        struct crypt_s390_des3_128_ctx *dctx;
+        struct crypt_s390_des3_128_ctx *dctx = ctx;
 
-        dctx = ctx;
         crypt_s390_km(KM_TDEA_128_DECRYPT, dctx->key, dst, (void*)src,
-                        DES3_128_BLOCK_SIZE);
+                      DES3_128_BLOCK_SIZE);
+}
+
+static unsigned int des3_128_encrypt_ecb(const struct cipher_desc *desc,
+                                         u8 *out, const u8 *in,
+                                         unsigned int nbytes)
+{
+        struct crypt_s390_des3_128_ctx *sctx = crypto_tfm_ctx(desc->tfm);
+        int ret;
+
+        /* only use complete blocks */
+        nbytes &= ~(DES3_128_BLOCK_SIZE - 1);
+        ret = crypt_s390_km(KM_TDEA_128_ENCRYPT, sctx->key, out, in, nbytes);
+        BUG_ON((ret < 0) || (ret != nbytes));
+
+        return nbytes;
+}
+
+static unsigned int des3_128_decrypt_ecb(const struct cipher_desc *desc,
+                                         u8 *out, const u8 *in,
+                                         unsigned int nbytes)
+{
+        struct crypt_s390_des3_128_ctx *sctx = crypto_tfm_ctx(desc->tfm);
+        int ret;
+
+        /* only use complete blocks */
+        nbytes &= ~(DES3_128_BLOCK_SIZE - 1);
+        ret = crypt_s390_km(KM_TDEA_128_DECRYPT, sctx->key, out, in, nbytes);
+        BUG_ON((ret < 0) || (ret != nbytes));
+
+        return nbytes;
+}
+
+static unsigned int des3_128_encrypt_cbc(const struct cipher_desc *desc,
+                                         u8 *out, const u8 *in,
+                                         unsigned int nbytes)
+{
+        struct crypt_s390_des3_128_ctx *sctx = crypto_tfm_ctx(desc->tfm);
+        int ret;
+
+        /* only use complete blocks */
+        nbytes &= ~(DES3_128_BLOCK_SIZE - 1);
+
+        memcpy(sctx->iv, desc->info, DES3_128_BLOCK_SIZE);
+        ret = crypt_s390_kmc(KMC_TDEA_128_ENCRYPT, &sctx->iv, out, in, nbytes);
+        BUG_ON((ret < 0) || (ret != nbytes));
+
+        memcpy(desc->info, sctx->iv, DES3_128_BLOCK_SIZE);
+        return nbytes;
+}
+
+static unsigned int des3_128_decrypt_cbc(const struct cipher_desc *desc,
+                                         u8 *out, const u8 *in,
+                                         unsigned int nbytes)
+{
+        struct crypt_s390_des3_128_ctx *sctx = crypto_tfm_ctx(desc->tfm);
+        int ret;
+
+        /* only use complete blocks */
+        nbytes &= ~(DES3_128_BLOCK_SIZE - 1);
+
+        memcpy(&sctx->iv, desc->info, DES3_128_BLOCK_SIZE);
+        ret = crypt_s390_kmc(KMC_TDEA_128_DECRYPT, &sctx->iv, out, in, nbytes);
+        BUG_ON((ret < 0) || (ret != nbytes));
+
+        return nbytes;
 }
 
 static struct crypto_alg des3_128_alg = {
@@ -156,12 +274,19 @@ static struct crypto_alg des3_128_alg = {
         .cra_ctxsize            =       sizeof(struct crypt_s390_des3_128_ctx),
         .cra_module             =       THIS_MODULE,
         .cra_list               =       LIST_HEAD_INIT(des3_128_alg.cra_list),
-        .cra_u                  =       { .cipher = {
-        .cia_min_keysize        =       DES3_128_KEY_SIZE,
-        .cia_max_keysize        =       DES3_128_KEY_SIZE,
-        .cia_setkey             =       des3_128_setkey,
-        .cia_encrypt            =       des3_128_encrypt,
-        .cia_decrypt            =       des3_128_decrypt } }
+        .cra_u                  =       {
+                .cipher = {
+                        .cia_min_keysize        =       DES3_128_KEY_SIZE,
+                        .cia_max_keysize        =       DES3_128_KEY_SIZE,
+                        .cia_setkey             =       des3_128_setkey,
+                        .cia_encrypt            =       des3_128_encrypt,
+                        .cia_decrypt            =       des3_128_decrypt,
+                        .cia_encrypt_ecb        =       des3_128_encrypt_ecb,
+                        .cia_decrypt_ecb        =       des3_128_decrypt_ecb,
+                        .cia_encrypt_cbc        =       des3_128_encrypt_cbc,
+                        .cia_decrypt_cbc        =       des3_128_decrypt_cbc,
+                }
+        }
 };
 
 /*
@@ -177,50 +302,108 @@ static struct crypto_alg des3_128_alg = {
  *   property.
  *
  */
-static int
-des3_192_setkey(void *ctx, const u8 *key, unsigned int keylen, u32 *flags)
+static int des3_192_setkey(void *ctx, const u8 *key, unsigned int keylen,
+                           u32 *flags)
 {
         int i, ret;
-        struct crypt_s390_des3_192_ctx *dctx;
-        const u8* temp_key;
+        struct crypt_s390_des3_192_ctx *dctx = ctx;
+        const u8* temp_key = key;
 
-        dctx = ctx;
-        temp_key = key;
         if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE) &&
             memcmp(&key[DES_KEY_SIZE], &key[DES_KEY_SIZE * 2],
-                                                DES_KEY_SIZE))) {
+                   DES_KEY_SIZE))) {
 
                 *flags |= CRYPTO_TFM_RES_BAD_KEY_SCHED;
                 return -EINVAL;
         }
         for (i = 0; i < 3; i++, temp_key += DES_KEY_SIZE) {
                 ret = crypto_des_check_key(temp_key, DES_KEY_SIZE, flags);
-                if (ret < 0){
+                if (ret < 0)
                         return ret;
-                }
         }
         memcpy(dctx->key, key, keylen);
         return 0;
 }
 
-static void
-des3_192_encrypt(void *ctx, u8 *dst, const u8 *src)
+static void des3_192_encrypt(void *ctx, u8 *dst, const u8 *src)
 {
-        struct crypt_s390_des3_192_ctx *dctx;
+        struct crypt_s390_des3_192_ctx *dctx = ctx;
 
-        dctx = ctx;
         crypt_s390_km(KM_TDEA_192_ENCRYPT, dctx->key, dst, (void*)src,
-                        DES3_192_BLOCK_SIZE);
+                      DES3_192_BLOCK_SIZE);
 }
 
-static void
-des3_192_decrypt(void *ctx, u8 *dst, const u8 *src)
+static void des3_192_decrypt(void *ctx, u8 *dst, const u8 *src)
 {
-        struct crypt_s390_des3_192_ctx *dctx;
+        struct crypt_s390_des3_192_ctx *dctx = ctx;
 
-        dctx = ctx;
         crypt_s390_km(KM_TDEA_192_DECRYPT, dctx->key, dst, (void*)src,
-                        DES3_192_BLOCK_SIZE);
+                      DES3_192_BLOCK_SIZE);
+}
+
+static unsigned int des3_192_encrypt_ecb(const struct cipher_desc *desc,
+                                         u8 *out, const u8 *in,
+                                         unsigned int nbytes)
+{
+        struct crypt_s390_des3_192_ctx *sctx = crypto_tfm_ctx(desc->tfm);
+        int ret;
+
+        /* only use complete blocks */
+        nbytes &= ~(DES3_192_BLOCK_SIZE - 1);
+        ret = crypt_s390_km(KM_TDEA_192_ENCRYPT, sctx->key, out, in, nbytes);
+        BUG_ON((ret < 0) || (ret != nbytes));
+
+        return nbytes;
+}
+
+static unsigned int des3_192_decrypt_ecb(const struct cipher_desc *desc,
+                                         u8 *out, const u8 *in,
+                                         unsigned int nbytes)
+{
+        struct crypt_s390_des3_192_ctx *sctx = crypto_tfm_ctx(desc->tfm);
+        int ret;
+
+        /* only use complete blocks */
+        nbytes &= ~(DES3_192_BLOCK_SIZE - 1);
+        ret = crypt_s390_km(KM_TDEA_192_DECRYPT, sctx->key, out, in, nbytes);
+        BUG_ON((ret < 0) || (ret != nbytes));
+
+        return nbytes;
+}
+
+static unsigned int des3_192_encrypt_cbc(const struct cipher_desc *desc,
+                                         u8 *out, const u8 *in,
+                                         unsigned int nbytes)
+{
+        struct crypt_s390_des3_192_ctx *sctx = crypto_tfm_ctx(desc->tfm);
+        int ret;
+
+        /* only use complete blocks */
+        nbytes &= ~(DES3_192_BLOCK_SIZE - 1);
+
+        memcpy(sctx->iv, desc->info, DES3_192_BLOCK_SIZE);
+        ret = crypt_s390_kmc(KMC_TDEA_192_ENCRYPT, &sctx->iv, out, in, nbytes);
+        BUG_ON((ret < 0) || (ret != nbytes));
+
+        memcpy(desc->info, sctx->iv, DES3_192_BLOCK_SIZE);
+        return nbytes;
+}
+
+static unsigned int des3_192_decrypt_cbc(const struct cipher_desc *desc,
+                                         u8 *out, const u8 *in,
+                                         unsigned int nbytes)
+{
+        struct crypt_s390_des3_192_ctx *sctx = crypto_tfm_ctx(desc->tfm);
+        int ret;
+
+        /* only use complete blocks */
+        nbytes &= ~(DES3_192_BLOCK_SIZE - 1);
+
+        memcpy(&sctx->iv, desc->info, DES3_192_BLOCK_SIZE);
+        ret = crypt_s390_kmc(KMC_TDEA_192_DECRYPT, &sctx->iv, out, in, nbytes);
+        BUG_ON((ret < 0) || (ret != nbytes));
+
+        return nbytes;
 }
 
 static struct crypto_alg des3_192_alg = {
@@ -230,44 +413,43 @@ static struct crypto_alg des3_192_alg = {
         .cra_ctxsize            =       sizeof(struct crypt_s390_des3_192_ctx),
         .cra_module             =       THIS_MODULE,
         .cra_list               =       LIST_HEAD_INIT(des3_192_alg.cra_list),
-        .cra_u                  =       { .cipher = {
-        .cia_min_keysize        =       DES3_192_KEY_SIZE,
-        .cia_max_keysize        =       DES3_192_KEY_SIZE,
-        .cia_setkey             =       des3_192_setkey,
-        .cia_encrypt            =       des3_192_encrypt,
-        .cia_decrypt            =       des3_192_decrypt } }
+        .cra_u                  =       {
+                .cipher = {
+                        .cia_min_keysize        =       DES3_192_KEY_SIZE,
+                        .cia_max_keysize        =       DES3_192_KEY_SIZE,
+                        .cia_setkey             =       des3_192_setkey,
+                        .cia_encrypt            =       des3_192_encrypt,
+                        .cia_decrypt            =       des3_192_decrypt,
+                        .cia_encrypt_ecb        =       des3_192_encrypt_ecb,
+                        .cia_decrypt_ecb        =       des3_192_decrypt_ecb,
+                        .cia_encrypt_cbc        =       des3_192_encrypt_cbc,
+                        .cia_decrypt_cbc        =       des3_192_decrypt_cbc,
+                }
+        }
 };
 
-
-
-static int
-init(void)
+static int init(void)
 {
-        int ret;
+        int ret = 0;
 
         if (!crypt_s390_func_available(KM_DEA_ENCRYPT) ||
             !crypt_s390_func_available(KM_TDEA_128_ENCRYPT) ||
-            !crypt_s390_func_available(KM_TDEA_192_ENCRYPT)){
+            !crypt_s390_func_available(KM_TDEA_192_ENCRYPT))
                 return -ENOSYS;
-        }
 
-        ret = 0;
-        ret |= (crypto_register_alg(&des_alg) == 0)? 0:1;
-        ret |= (crypto_register_alg(&des3_128_alg) == 0)? 0:2;
-        ret |= (crypto_register_alg(&des3_192_alg) == 0)? 0:4;
-        if (ret){
+        ret |= (crypto_register_alg(&des_alg) == 0) ? 0:1;
+        ret |= (crypto_register_alg(&des3_128_alg) == 0) ? 0:2;
+        ret |= (crypto_register_alg(&des3_192_alg) == 0) ? 0:4;
+        if (ret) {
                 crypto_unregister_alg(&des3_192_alg);
                 crypto_unregister_alg(&des3_128_alg);
                 crypto_unregister_alg(&des_alg);
                 return -EEXIST;
         }
-
-        printk(KERN_INFO "crypt_s390: des_s390 loaded.\n");
         return 0;
 }
 
-static void __exit
-fini(void)
+static void __exit fini(void)
 {
         crypto_unregister_alg(&des3_192_alg);
         crypto_unregister_alg(&des3_128_alg);
diff --git a/arch/s390/crypto/sha256_s390.c b/arch/s390/crypto/sha256_s390.c
index b75bdbd476c7..1ec5e92b3454 100644
--- a/arch/s390/crypto/sha256_s390.c
+++ b/arch/s390/crypto/sha256_s390.c
@@ -51,6 +51,7 @@ static void sha256_update(void *ctx, const u8 *data, unsigned int len)
 {
         struct s390_sha256_ctx *sctx = ctx;
         unsigned int index;
+        int ret;
 
         /* how much is already in the buffer? */
         index = sctx->count / 8 & 0x3f;
@@ -58,15 +59,29 @@ static void sha256_update(void *ctx, const u8 *data, unsigned int len)
         /* update message bit length */
         sctx->count += len * 8;
 
-        /* process one block */
-        if ((index + len) >= SHA256_BLOCK_SIZE) {
+        if ((index + len) < SHA256_BLOCK_SIZE)
+                goto store;
+
+        /* process one stored block */
+        if (index) {
                 memcpy(sctx->buf + index, data, SHA256_BLOCK_SIZE - index);
-                crypt_s390_kimd(KIMD_SHA_256, sctx->state, sctx->buf,
-                                SHA256_BLOCK_SIZE);
+                ret = crypt_s390_kimd(KIMD_SHA_256, sctx->state, sctx->buf,
+                                      SHA256_BLOCK_SIZE);
+                BUG_ON(ret != SHA256_BLOCK_SIZE);
                 data += SHA256_BLOCK_SIZE - index;
                 len -= SHA256_BLOCK_SIZE - index;
         }
 
+        /* process as many blocks as possible */
+        if (len >= SHA256_BLOCK_SIZE) {
+                ret = crypt_s390_kimd(KIMD_SHA_256, sctx->state, data,
+                                      len & ~(SHA256_BLOCK_SIZE - 1));
+                BUG_ON(ret != (len & ~(SHA256_BLOCK_SIZE - 1)));
+                data += ret;
+                len -= ret;
+        }
+
+store:
         /* anything left? */
         if (len)
                 memcpy(sctx->buf + index , data, len);
@@ -119,9 +134,9 @@ static struct crypto_alg alg = {
         .cra_list       =       LIST_HEAD_INIT(alg.cra_list),
         .cra_u          =       { .digest = {
         .dia_digestsize =       SHA256_DIGEST_SIZE,
-        .dia_init       =       sha256_init,
-        .dia_update     =       sha256_update,
-        .dia_final      =       sha256_final } }
+        .dia_init       =       sha256_init,
+        .dia_update     =       sha256_update,
+        .dia_final      =       sha256_final } }
 };
 
 static int init(void)
diff --git a/arch/s390/kernel/process.c b/arch/s390/kernel/process.c
index 2ff90a1a1056..008c74526fd3 100644
--- a/arch/s390/kernel/process.c
+++ b/arch/s390/kernel/process.c
@@ -58,10 +58,18 @@ asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");
  */
 unsigned long thread_saved_pc(struct task_struct *tsk)
 {
-        struct stack_frame *sf;
+        struct stack_frame *sf, *low, *high;
 
-        sf = (struct stack_frame *) tsk->thread.ksp;
-        sf = (struct stack_frame *) sf->back_chain;
+        if (!tsk || !task_stack_page(tsk))
+                return 0;
+        low = task_stack_page(tsk);
+        high = (struct stack_frame *) task_pt_regs(tsk);
+        sf = (struct stack_frame *) (tsk->thread.ksp & PSW_ADDR_INSN);
+        if (sf <= low || sf > high)
+                return 0;
+        sf = (struct stack_frame *) (sf->back_chain & PSW_ADDR_INSN);
+        if (sf <= low || sf > high)
+                return 0;
         return sf->gprs[8];
 }
 
diff --git a/arch/s390/kernel/setup.c b/arch/s390/kernel/setup.c
index b03847d100d9..de8784267473 100644
--- a/arch/s390/kernel/setup.c
+++ b/arch/s390/kernel/setup.c
@@ -268,7 +268,7 @@ static void do_machine_restart_nonsmp(char * __unused)
         reipl_diag();
 
         if (MACHINE_IS_VM)
-                cpcmd ("IPL", NULL, 0);
+                cpcmd ("IPL", NULL, 0, NULL);
         else
                 reipl (0x10000 | S390_lowcore.ipl_device);
 }
@@ -276,14 +276,14 @@ static void do_machine_restart_nonsmp(char * __unused)
 static void do_machine_halt_nonsmp(void)
 {
         if (MACHINE_IS_VM && strlen(vmhalt_cmd) > 0)
-                cpcmd(vmhalt_cmd, NULL, 0);
+                cpcmd(vmhalt_cmd, NULL, 0, NULL);
         signal_processor(smp_processor_id(), sigp_stop_and_store_status);
 }
 
 static void do_machine_power_off_nonsmp(void)
 {
         if (MACHINE_IS_VM && strlen(vmpoff_cmd) > 0)
-                cpcmd(vmpoff_cmd, NULL, 0);
+                cpcmd(vmpoff_cmd, NULL, 0, NULL);
         signal_processor(smp_processor_id(), sigp_stop_and_store_status);
 }
 
@@ -315,6 +315,11 @@ void machine_power_off(void)
         _machine_power_off();
 }
 
+/*
+ * Dummy power off function.
+ */
+void (*pm_power_off)(void) = machine_power_off;
+
 static void __init
 add_memory_hole(unsigned long start, unsigned long end)
 {
diff --git a/arch/s390/kernel/time.c b/arch/s390/kernel/time.c
index b0d8ca8e5eeb..7c0fe152a111 100644
--- a/arch/s390/kernel/time.c
+++ b/arch/s390/kernel/time.c
@@ -214,7 +214,7 @@ void account_ticks(struct pt_regs *regs)
 #endif
 
 #ifdef CONFIG_VIRT_CPU_ACCOUNTING
-        account_user_vtime(current);
+        account_tick_vtime(current);
 #else
         while (ticks--)
                 update_process_times(user_mode(regs));
diff --git a/arch/s390/kernel/vtime.c b/arch/s390/kernel/vtime.c
index 22a895ecb7a4..dfe6f0856617 100644
--- a/arch/s390/kernel/vtime.c
+++ b/arch/s390/kernel/vtime.c
@@ -32,7 +32,7 @@ DEFINE_PER_CPU(struct vtimer_queue, virt_cpu_timer);
  * Update process times based on virtual cpu times stored by entry.S
  * to the lowcore fields user_timer, system_timer & steal_clock.
  */
-void account_user_vtime(struct task_struct *tsk)
+void account_tick_vtime(struct task_struct *tsk)
 {
         cputime_t cputime;
         __u64 timer, clock;
@@ -76,6 +76,31 @@ void account_user_vtime(struct task_struct *tsk)
  * Update process times based on virtual cpu times stored by entry.S
  * to the lowcore fields user_timer, system_timer & steal_clock.
  */
+void account_vtime(struct task_struct *tsk)
+{
+        cputime_t cputime;
+        __u64 timer;
+
+        timer = S390_lowcore.last_update_timer;
+        asm volatile ("  STPT %0"    /* Store current cpu timer value */
+                      : "=m" (S390_lowcore.last_update_timer) );
+        S390_lowcore.system_timer += timer - S390_lowcore.last_update_timer;
+
+        cputime = S390_lowcore.user_timer >> 12;
+        S390_lowcore.user_timer -= cputime << 12;
+        S390_lowcore.steal_clock -= cputime << 12;
+        account_user_time(tsk, cputime);
+
+        cputime =  S390_lowcore.system_timer >> 12;
+        S390_lowcore.system_timer -= cputime << 12;
+        S390_lowcore.steal_clock -= cputime << 12;
+        account_system_time(tsk, 0, cputime);
+}
+
+/*
+ * Update process times based on virtual cpu times stored by entry.S
+ * to the lowcore fields user_timer, system_timer & steal_clock.
+ */
 void account_system_vtime(struct task_struct *tsk)
 {
         cputime_t cputime;
diff --git a/arch/s390/lib/Makefile b/arch/s390/lib/Makefile
index d9b97b3c597f..f20b51ff1d86 100644
--- a/arch/s390/lib/Makefile
+++ b/arch/s390/lib/Makefile
@@ -4,5 +4,6 @@
 
 EXTRA_AFLAGS := -traditional
 
-lib-y += delay.o string.o spinlock.o
+lib-y += delay.o string.o
 lib-y += $(if $(CONFIG_64BIT),uaccess64.o,uaccess.o)
+lib-$(CONFIG_SMP) += spinlock.o
\ No newline at end of file
diff --git a/arch/s390/lib/spinlock.c b/arch/s390/lib/spinlock.c
index 68d79c502081..60f80a4eed4e 100644
--- a/arch/s390/lib/spinlock.c
+++ b/arch/s390/lib/spinlock.c
@@ -13,7 +13,6 @@
 #include <linux/init.h>
 #include <asm/io.h>
 
-atomic_t spin_retry_counter;
 int spin_retry = 1000;
 
 /**
@@ -45,7 +44,6 @@ _raw_spin_lock_wait(raw_spinlock_t *lp, unsigned int pc)
                         _diag44();
                         count = spin_retry;
                 }
-                atomic_inc(&spin_retry_counter);
                 if (_raw_compare_and_swap(&lp->lock, 0, pc) == 0)
                         return;
         }
@@ -58,7 +56,6 @@ _raw_spin_trylock_retry(raw_spinlock_t *lp, unsigned int pc)
         int count = spin_retry;
 
         while (count-- > 0) {
-                atomic_inc(&spin_retry_counter);
                 if (_raw_compare_and_swap(&lp->lock, 0, pc) == 0)
                         return 1;
         }
@@ -77,7 +74,6 @@ _raw_read_lock_wait(raw_rwlock_t *rw)
                         _diag44();
                         count = spin_retry;
                 }
-                atomic_inc(&spin_retry_counter);
                 old = rw->lock & 0x7fffffffU;
                 if (_raw_compare_and_swap(&rw->lock, old, old + 1) == old)
                         return;
@@ -92,7 +88,6 @@ _raw_read_trylock_retry(raw_rwlock_t *rw)
         int count = spin_retry;
 
         while (count-- > 0) {
-                atomic_inc(&spin_retry_counter);
                 old = rw->lock & 0x7fffffffU;
                 if (_raw_compare_and_swap(&rw->lock, old, old + 1) == old)
                         return 1;
@@ -111,7 +106,6 @@ _raw_write_lock_wait(raw_rwlock_t *rw)
                         _diag44();
                         count = spin_retry;
                 }
-                atomic_inc(&spin_retry_counter);
                 if (_raw_compare_and_swap(&rw->lock, 0, 0x80000000) == 0)
                         return;
         }
@@ -124,7 +118,6 @@ _raw_write_trylock_retry(raw_rwlock_t *rw)
         int count = spin_retry;
 
         while (count-- > 0) {
-                atomic_inc(&spin_retry_counter);
                 if (_raw_compare_and_swap(&rw->lock, 0, 0x80000000) == 0)
                         return 1;
         }
diff --git a/arch/sh/kernel/cpu/bus.c b/arch/sh/kernel/cpu/bus.c
index d4fee2a79373..3278d234bb1b 100644
--- a/arch/sh/kernel/cpu/bus.c
+++ b/arch/sh/kernel/cpu/bus.c
@@ -53,21 +53,6 @@ static int sh_bus_resume(struct device *dev)
         return 0;
 }
 
-static struct device sh_bus_devices[SH_NR_BUSES] = {
-        {
-                .bus_id         = SH_BUS_NAME_VIRT,
-        },
-};
-
-struct bus_type sh_bus_types[SH_NR_BUSES] = {
-        {
-                .name           = SH_BUS_NAME_VIRT,
-                .match          = sh_bus_match,
-                .suspend        = sh_bus_suspend,
-                .resume         = sh_bus_resume,
-        },
-};
-
 static int sh_device_probe(struct device *dev)
 {
         struct sh_dev *shdev = to_sh_dev(dev);
@@ -90,6 +75,23 @@ static int sh_device_remove(struct device *dev)
         return 0;
 }
 
+static struct device sh_bus_devices[SH_NR_BUSES] = {
+        {
+                .bus_id         = SH_BUS_NAME_VIRT,
+        },
+};
+
+struct bus_type sh_bus_types[SH_NR_BUSES] = {
+        {
+                .name           = SH_BUS_NAME_VIRT,
+                .match          = sh_bus_match,
+                .probe          = sh_bus_probe,
+                .remove         = sh_bus_remove,
+                .suspend        = sh_bus_suspend,
+                .resume         = sh_bus_resume,
+        },
+};
+
 int sh_device_register(struct sh_dev *dev)
 {
         if (!dev)
@@ -133,8 +135,6 @@ int sh_driver_register(struct sh_driver *drv)
                 return -EINVAL;
         }
 
-        drv->drv.probe  = sh_device_probe;
-        drv->drv.remove = sh_device_remove;
         drv->drv.bus    = &sh_bus_types[drv->bus_id];
 
         return driver_register(&drv->drv);
diff --git a/arch/um/Makefile b/arch/um/Makefile
index 322972fd064e..45435ff589c1 100644
--- a/arch/um/Makefile
+++ b/arch/um/Makefile
@@ -67,7 +67,8 @@ USER_CFLAGS := $(patsubst -D__KERNEL__,,$(USER_CFLAGS)) $(ARCH_INCLUDE) \
 # in CFLAGS.  Otherwise, it would cause ld to complain about the two different
 # errnos.
 
-CFLAGS += -Derrno=kernel_errno -Dsigprocmask=kernel_sigprocmask
+CFLAGS += -Derrno=kernel_errno -Dsigprocmask=kernel_sigprocmask \
+        -Dmktime=kernel_mktime
 CFLAGS += $(call cc-option,-fno-unit-at-a-time,)
 
 include $(srctree)/$(ARCH_DIR)/Makefile-$(SUBARCH)