350 files changed, 11731 insertions, 15543 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/arm26/kernel/irq.c b/arch/arm26/kernel/irq.c
index f3cc1036e5bc..0934e6fba606 100644
--- a/arch/arm26/kernel/irq.c
+++ b/arch/arm26/kernel/irq.c
@@ -141,7 +141,7 @@ int show_interrupts(struct seq_file *p, void *v)
         if (i < NR_IRQS) {
                 action = irq_desc[i].action;
                 if (!action)
-                        continue;
+                        goto out;
                 seq_printf(p, "%3d: %10u ", i, kstat_irqs(i));
                 seq_printf(p, "  %s", action->name);
                 for (action = action->next; action; action = action->next) {
@@ -152,6 +152,7 @@ int show_interrupts(struct seq_file *p, void *v)
                 show_fiq_list(p, v);
                 seq_printf(p, "Err: %10lu\n", irq_err_count);
         }
+out:
         return 0;
 }
 
diff --git a/arch/arm26/kernel/ptrace.c b/arch/arm26/kernel/ptrace.c
index 3c3371d4683e..282e24d79328 100644
--- a/arch/arm26/kernel/ptrace.c
+++ b/arch/arm26/kernel/ptrace.c
@@ -527,7 +527,7 @@ static int ptrace_getfpregs(struct task_struct *tsk, void *ufp)
 static int ptrace_setfpregs(struct task_struct *tsk, void *ufp)
 {
         set_stopped_child_used_math(tsk);
-        return copy_from_user(&task_threas_info(tsk)->fpstate, ufp,
+        return copy_from_user(&task_thread_info(tsk)->fpstate, ufp,
                               sizeof(struct user_fp)) ? -EFAULT : 0;
 }
 
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..36bef6543ac1 100644
--- a/arch/i386/Makefile
+++ b/arch/i386/Makefile
@@ -37,14 +37,11 @@ CFLAGS += $(call cc-option,-mpreferred-stack-boundary=2)
 # CPU-specific tuning. Anything which can be shared with UML should go here.
 include $(srctree)/arch/i386/Makefile.cpu
 
-# -mregparm=3 works ok on gcc-3.0 and later
-#
-cflags-$(CONFIG_REGPARM) += $(shell if [ $(call cc-version) -ge 0300 ] ; then \
-                            echo "-mregparm=3"; fi ;)
+cflags-$(CONFIG_REGPARM) += -mregparm=3
 
-# 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/cpu/cpufreq/powernow-k8.c b/arch/i386/kernel/cpu/cpufreq/powernow-k8.c
index 0fbbd4c1072e..e11a09207ec8 100644
--- a/arch/i386/kernel/cpu/cpufreq/powernow-k8.c
+++ b/arch/i386/kernel/cpu/cpufreq/powernow-k8.c
@@ -980,7 +980,7 @@ static int powernowk8_verify(struct cpufreq_policy *pol)
 }
 
 /* per CPU init entry point to the driver */
-static int __init powernowk8_cpu_init(struct cpufreq_policy *pol)
+static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
 {
         struct powernow_k8_data *data;
         cpumask_t oldmask = CPU_MASK_ALL;
@@ -1141,7 +1141,7 @@ static struct cpufreq_driver cpufreq_amd64_driver = {
 };
 
 /* driver entry point for init */
-static int __init powernowk8_init(void)
+static int __cpuinit powernowk8_init(void)
 {
         unsigned int i, supported_cpus = 0;
 
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/kernel/vm86.c b/arch/i386/kernel/vm86.c
index 0c90ae54ddfa..f51c894a7da5 100644
--- a/arch/i386/kernel/vm86.c
+++ b/arch/i386/kernel/vm86.c
@@ -4,7 +4,7 @@
  *  Copyright (C) 1994  Linus Torvalds
  *
  *  29 dec 2001 - Fixed oopses caused by unchecked access to the vm86
- *                stack - Manfred Spraul <manfreds@colorfullife.com>
+ *                stack - Manfred Spraul <manfred@colorfullife.com>
  *
  *  22 mar 2002 - Manfred detected the stackfaults, but didn't handle
  *                them correctly. Now the emulation will be in a
diff --git a/arch/i386/mm/init.c b/arch/i386/mm/init.c
index 7df494b51a5b..2700f01994ba 100644
--- a/arch/i386/mm/init.c
+++ b/arch/i386/mm/init.c
@@ -268,7 +268,7 @@ static void __init permanent_kmaps_init(pgd_t *pgd_base)
         pkmap_page_table = pte; 
 }
 
-static void __devinit free_new_highpage(struct page *page)
+static void __meminit free_new_highpage(struct page *page)
 {
         set_page_count(page, 1);
         __free_page(page);
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/perfmon.c b/arch/ia64/kernel/perfmon.c
index bd87cb6b7a81..2ea4b39efffa 100644
--- a/arch/ia64/kernel/perfmon.c
+++ b/arch/ia64/kernel/perfmon.c
@@ -628,9 +628,11 @@ static int pfm_write_ibr_dbr(int mode, pfm_context_t *ctx, void *arg, int count,
 
 #include "perfmon_itanium.h"
 #include "perfmon_mckinley.h"
+#include "perfmon_montecito.h"
 #include "perfmon_generic.h"
 
 static pmu_config_t *pmu_confs[]={
+        &pmu_conf_mont,
         &pmu_conf_mck,
         &pmu_conf_ita,
         &pmu_conf_gen, /* must be last */
diff --git a/arch/ia64/kernel/perfmon_montecito.h b/arch/ia64/kernel/perfmon_montecito.h
new file mode 100644
index 000000000000..cd06ac6a686c
--- /dev/null
+++ b/arch/ia64/kernel/perfmon_montecito.h
@@ -0,0 +1,269 @@
+/*
+ * This file contains the Montecito PMU register description tables
+ * and pmc checker used by perfmon.c.
+ *
+ * Copyright (c) 2005-2006 Hewlett-Packard Development Company, L.P.
+ *               Contributed by Stephane Eranian <eranian@hpl.hp.com>
+ */
+static int pfm_mont_pmc_check(struct task_struct *task, pfm_context_t *ctx, unsigned int cnum, unsigned long *val, struct pt_regs *regs);
+
+#define RDEP_MONT_ETB   (RDEP(38)|RDEP(39)|RDEP(48)|RDEP(49)|RDEP(50)|RDEP(51)|RDEP(52)|RDEP(53)|RDEP(54)|\
+                         RDEP(55)|RDEP(56)|RDEP(57)|RDEP(58)|RDEP(59)|RDEP(60)|RDEP(61)|RDEP(62)|RDEP(63))
+#define RDEP_MONT_DEAR  (RDEP(32)|RDEP(33)|RDEP(36))
+#define RDEP_MONT_IEAR  (RDEP(34)|RDEP(35))
+
+static pfm_reg_desc_t pfm_mont_pmc_desc[PMU_MAX_PMCS]={
+/* pmc0  */ { PFM_REG_CONTROL , 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {0,0, 0, 0}},
+/* pmc1  */ { PFM_REG_CONTROL , 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {0,0, 0, 0}},
+/* pmc2  */ { PFM_REG_CONTROL , 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {0,0, 0, 0}},
+/* pmc3  */ { PFM_REG_CONTROL , 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {0,0, 0, 0}},
+/* pmc4  */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(4),0, 0, 0}, {0,0, 0, 0}},
+/* pmc5  */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(5),0, 0, 0}, {0,0, 0, 0}},
+/* pmc6  */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(6),0, 0, 0}, {0,0, 0, 0}},
+/* pmc7  */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(7),0, 0, 0}, {0,0, 0, 0}},
+/* pmc8  */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(8),0, 0, 0}, {0,0, 0, 0}},
+/* pmc9  */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(9),0, 0, 0}, {0,0, 0, 0}},
+/* pmc10 */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(10),0, 0, 0}, {0,0, 0, 0}},
+/* pmc11 */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(11),0, 0, 0}, {0,0, 0, 0}},
+/* pmc12 */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(12),0, 0, 0}, {0,0, 0, 0}},
+/* pmc13 */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(13),0, 0, 0}, {0,0, 0, 0}},
+/* pmc14 */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(14),0, 0, 0}, {0,0, 0, 0}},
+/* pmc15 */ { PFM_REG_COUNTING, 6, 0x2000000, 0x7c7fff7f, NULL, pfm_mont_pmc_check, {RDEP(15),0, 0, 0}, {0,0, 0, 0}},
+/* pmc16 */ { PFM_REG_NOTIMPL, },
+/* pmc17 */ { PFM_REG_NOTIMPL, },
+/* pmc18 */ { PFM_REG_NOTIMPL, },
+/* pmc19 */ { PFM_REG_NOTIMPL, },
+/* pmc20 */ { PFM_REG_NOTIMPL, },
+/* pmc21 */ { PFM_REG_NOTIMPL, },
+/* pmc22 */ { PFM_REG_NOTIMPL, },
+/* pmc23 */ { PFM_REG_NOTIMPL, },
+/* pmc24 */ { PFM_REG_NOTIMPL, },
+/* pmc25 */ { PFM_REG_NOTIMPL, },
+/* pmc26 */ { PFM_REG_NOTIMPL, },
+/* pmc27 */ { PFM_REG_NOTIMPL, },
+/* pmc28 */ { PFM_REG_NOTIMPL, },
+/* pmc29 */ { PFM_REG_NOTIMPL, },
+/* pmc30 */ { PFM_REG_NOTIMPL, },
+/* pmc31 */ { PFM_REG_NOTIMPL, },
+/* pmc32 */ { PFM_REG_CONFIG,  0, 0x30f01ffffffffff, 0x30f01ffffffffff, NULL, pfm_mont_pmc_check, {0,0, 0, 0}, {0,0, 0, 0}},
+/* pmc33 */ { PFM_REG_CONFIG,  0, 0x0,  0x1ffffffffff, NULL, pfm_mont_pmc_check, {0,0, 0, 0}, {0,0, 0, 0}},
+/* pmc34 */ { PFM_REG_CONFIG,  0, 0xf01ffffffffff, 0xf01ffffffffff, NULL, pfm_mont_pmc_check, {0,0, 0, 0}, {0,0, 0, 0}},
+/* pmc35 */ { PFM_REG_CONFIG,  0, 0x0,  0x1ffffffffff, NULL, pfm_mont_pmc_check, {0,0, 0, 0}, {0,0, 0, 0}},
+/* pmc36 */ { PFM_REG_CONFIG,  0, 0xfffffff0, 0xf, NULL, pfm_mont_pmc_check, {0,0, 0, 0}, {0,0, 0, 0}},
+/* pmc37 */ { PFM_REG_MONITOR, 4, 0x0, 0x3fff, NULL, pfm_mont_pmc_check, {RDEP_MONT_IEAR, 0, 0, 0}, {0, 0, 0, 0}},
+/* pmc38 */ { PFM_REG_CONFIG,  0, 0xdb6, 0x2492, NULL, pfm_mont_pmc_check, {0,0, 0, 0}, {0,0, 0, 0}},
+/* pmc39 */ { PFM_REG_MONITOR, 6, 0x0, 0xffcf, NULL, pfm_mont_pmc_check, {RDEP_MONT_ETB,0, 0, 0}, {0,0, 0, 0}},
+/* pmc40 */ { PFM_REG_MONITOR, 6, 0x2000000, 0xf01cf, NULL, pfm_mont_pmc_check, {RDEP_MONT_DEAR,0, 0, 0}, {0,0, 0, 0}},
+/* pmc41 */ { PFM_REG_CONFIG,  0, 0x00002078fefefefe, 0x1e00018181818, NULL, pfm_mont_pmc_check, {0,0, 0, 0}, {0,0, 0, 0}},
+/* pmc42 */ { PFM_REG_MONITOR, 6, 0x0, 0x7ff4f, NULL, pfm_mont_pmc_check, {RDEP_MONT_ETB,0, 0, 0}, {0,0, 0, 0}},
+            { PFM_REG_END    , 0, 0x0, -1, NULL, NULL, {0,}, {0,}}, /* end marker */
+};
+
+static pfm_reg_desc_t pfm_mont_pmd_desc[PMU_MAX_PMDS]={
+/* pmd0  */ { PFM_REG_NOTIMPL, }, 
+/* pmd1  */ { PFM_REG_NOTIMPL, },
+/* pmd2  */ { PFM_REG_NOTIMPL, },
+/* pmd3  */ { PFM_REG_NOTIMPL, },
+/* pmd4  */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(4),0, 0, 0}},
+/* pmd5  */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(5),0, 0, 0}},
+/* pmd6  */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(6),0, 0, 0}},
+/* pmd7  */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(7),0, 0, 0}},
+/* pmd8  */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(8),0, 0, 0}}, 
+/* pmd9  */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(9),0, 0, 0}},
+/* pmd10 */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(10),0, 0, 0}},
+/* pmd11 */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(11),0, 0, 0}},
+/* pmd12 */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(12),0, 0, 0}},
+/* pmd13 */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(13),0, 0, 0}},
+/* pmd14 */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(14),0, 0, 0}},
+/* pmd15 */ { PFM_REG_COUNTING, 0, 0x0, -1, NULL, NULL, {0,0, 0, 0}, {RDEP(15),0, 0, 0}},
+/* pmd16 */ { PFM_REG_NOTIMPL, },
+/* pmd17 */ { PFM_REG_NOTIMPL, },
+/* pmd18 */ { PFM_REG_NOTIMPL, },
+/* pmd19 */ { PFM_REG_NOTIMPL, },
+/* pmd20 */ { PFM_REG_NOTIMPL, },
+/* pmd21 */ { PFM_REG_NOTIMPL, },
+/* pmd22 */ { PFM_REG_NOTIMPL, },
+/* pmd23 */ { PFM_REG_NOTIMPL, },
+/* pmd24 */ { PFM_REG_NOTIMPL, },
+/* pmd25 */ { PFM_REG_NOTIMPL, },
+/* pmd26 */ { PFM_REG_NOTIMPL, },
+/* pmd27 */ { PFM_REG_NOTIMPL, },
+/* pmd28 */ { PFM_REG_NOTIMPL, },
+/* pmd29 */ { PFM_REG_NOTIMPL, },
+/* pmd30 */ { PFM_REG_NOTIMPL, },
+/* pmd31 */ { PFM_REG_NOTIMPL, },
+/* pmd32 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP(33)|RDEP(36),0, 0, 0}, {RDEP(40),0, 0, 0}},
+/* pmd33 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP(32)|RDEP(36),0, 0, 0}, {RDEP(40),0, 0, 0}},
+/* pmd34 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP(35),0, 0, 0}, {RDEP(37),0, 0, 0}},
+/* pmd35 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP(34),0, 0, 0}, {RDEP(37),0, 0, 0}},
+/* pmd36 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP(32)|RDEP(33),0, 0, 0}, {RDEP(40),0, 0, 0}},
+/* pmd37 */ { PFM_REG_NOTIMPL, },
+/* pmd38 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+/* pmd39 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+/* pmd40 */ { PFM_REG_NOTIMPL, },
+/* pmd41 */ { PFM_REG_NOTIMPL, },
+/* pmd42 */ { PFM_REG_NOTIMPL, },
+/* pmd43 */ { PFM_REG_NOTIMPL, },
+/* pmd44 */ { PFM_REG_NOTIMPL, },
+/* pmd45 */ { PFM_REG_NOTIMPL, },
+/* pmd46 */ { PFM_REG_NOTIMPL, },
+/* pmd47 */ { PFM_REG_NOTIMPL, },
+/* pmd48 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+/* pmd49 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+/* pmd50 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+/* pmd51 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+/* pmd52 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+/* pmd53 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+/* pmd54 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+/* pmd55 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+/* pmd56 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+/* pmd57 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+/* pmd58 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+/* pmd59 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+/* pmd60 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+/* pmd61 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+/* pmd62 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+/* pmd63 */ { PFM_REG_BUFFER, 0, 0x0, -1, NULL, NULL, {RDEP_MONT_ETB,0, 0, 0}, {RDEP(39),0, 0, 0}},
+            { PFM_REG_END   , 0, 0x0, -1, NULL, NULL, {0,}, {0,}}, /* end marker */
+};
+
+/*
+ * PMC reserved fields must have their power-up values preserved
+ */
+static int
+pfm_mont_reserved(unsigned int cnum, unsigned long *val, struct pt_regs *regs)
+{
+        unsigned long tmp1, tmp2, ival = *val;
+
+        /* remove reserved areas from user value */
+        tmp1 = ival & PMC_RSVD_MASK(cnum);
+
+        /* get reserved fields values */
+        tmp2 = PMC_DFL_VAL(cnum) & ~PMC_RSVD_MASK(cnum);
+
+        *val = tmp1 | tmp2;
+
+        DPRINT(("pmc[%d]=0x%lx, mask=0x%lx, reset=0x%lx, val=0x%lx\n",
+                  cnum, ival, PMC_RSVD_MASK(cnum), PMC_DFL_VAL(cnum), *val));
+        return 0;
+}
+
+/*
+ * task can be NULL if the context is unloaded
+ */
+static int
+pfm_mont_pmc_check(struct task_struct *task, pfm_context_t *ctx, unsigned int cnum, unsigned long *val, struct pt_regs *regs)
+{
+        int ret = 0;
+        unsigned long val32 = 0, val38 = 0, val41 = 0;
+        unsigned long tmpval;
+        int check_case1 = 0;
+        int is_loaded;
+
+        /* first preserve the reserved fields */
+        pfm_mont_reserved(cnum, val, regs);
+
+        tmpval = *val;
+
+        /* sanity check */
+        if (ctx == NULL) return -EINVAL;
+
+        is_loaded = ctx->ctx_state == PFM_CTX_LOADED || ctx->ctx_state == PFM_CTX_MASKED;
+
+        /*
+         * we must clear the debug registers if pmc41 has a value which enable
+         * memory pipeline event constraints. In this case we need to clear the
+         * the debug registers if they have not yet been accessed. This is required
+         * to avoid picking stale state.
+         * PMC41 is "active" if:
+         *      one of the pmc41.cfg_dtagXX field is different from 0x3
+         * AND
+         *      at the corresponding pmc41.en_dbrpXX is set.
+         * AND
+         *      ctx_fl_using_dbreg == 0  (i.e., dbr not yet used)
+         */
+        DPRINT(("cnum=%u val=0x%lx, using_dbreg=%d loaded=%d\n", cnum, tmpval, ctx->ctx_fl_using_dbreg, is_loaded));
+
+        if (cnum == 41 && is_loaded 
+            && (tmpval & 0x1e00000000000) && (tmpval & 0x18181818UL) != 0x18181818UL && ctx->ctx_fl_using_dbreg == 0) {
+
+                DPRINT(("pmc[%d]=0x%lx has active pmc41 settings, clearing dbr\n", cnum, tmpval));
+
+                /* don't mix debug with perfmon */
+                if (task && (task->thread.flags & IA64_THREAD_DBG_VALID) != 0) return -EINVAL;
+
+                /*
+                 * a count of 0 will mark the debug registers if:
+                 * AND
+                 */
+                ret = pfm_write_ibr_dbr(PFM_DATA_RR, ctx, NULL, 0, regs);
+                if (ret) return ret;
+        }
+        /*
+         * we must clear the (instruction) debug registers if:
+         *      pmc38.ig_ibrpX is 0 (enabled)
+         * AND
+         *      ctx_fl_using_dbreg == 0  (i.e., dbr not yet used)
+         */
+        if (cnum == 38 && is_loaded && ((tmpval & 0x492UL) != 0x492UL) && ctx->ctx_fl_using_dbreg == 0) {
+
+                DPRINT(("pmc38=0x%lx has active pmc38 settings, clearing ibr\n", tmpval));
+
+                /* don't mix debug with perfmon */
+                if (task && (task->thread.flags & IA64_THREAD_DBG_VALID) != 0) return -EINVAL;
+
+                /*
+                 * a count of 0 will mark the debug registers as in use and also
+                 * ensure that they are properly cleared.
+                 */
+                ret = pfm_write_ibr_dbr(PFM_CODE_RR, ctx, NULL, 0, regs);
+                if (ret) return ret;
+
+        }
+        switch(cnum) {
+                case  32: val32 = *val;
+                          val38 = ctx->ctx_pmcs[38];
+                          val41 = ctx->ctx_pmcs[41];
+                          check_case1 = 1;
+                          break;
+                case  38: val38 = *val;
+                          val32 = ctx->ctx_pmcs[32];
+                          val41 = ctx->ctx_pmcs[41];
+                          check_case1 = 1;
+                          break;
+                case  41: val41 = *val;
+                          val32 = ctx->ctx_pmcs[32];
+                          val38 = ctx->ctx_pmcs[38];
+                          check_case1 = 1;
+                          break;
+        }
+        /* check illegal configuration which can produce inconsistencies in tagging
+         * i-side events in L1D and L2 caches
+         */
+        if (check_case1) {
+                ret =   (((val41 >> 45) & 0xf) == 0 && ((val32>>57) & 0x1) == 0)
+                     && ((((val38>>1) & 0x3) == 0x2 || ((val38>>1) & 0x3) == 0)
+                     ||  (((val38>>4) & 0x3) == 0x2 || ((val38>>4) & 0x3) == 0));
+                if (ret) {
+                        DPRINT(("invalid config pmc38=0x%lx pmc41=0x%lx pmc32=0x%lx\n", val38, val41, val32));
+                        return -EINVAL;
+                }
+        }
+        *val = tmpval;
+        return 0;
+}
+
+/*
+ * impl_pmcs, impl_pmds are computed at runtime to minimize errors!
+ */
+static pmu_config_t pmu_conf_mont={
+        .pmu_name        = "Montecito",
+        .pmu_family      = 0x20,
+        .flags           = PFM_PMU_IRQ_RESEND,
+        .ovfl_val        = (1UL << 47) - 1,
+        .pmd_desc        = pfm_mont_pmd_desc,
+        .pmc_desc        = pfm_mont_pmc_desc,
+        .num_ibrs        = 8,
+        .num_dbrs        = 8,
+        .use_rr_dbregs   = 1 /* debug register are use for range retrictions */
+};
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/init.c b/arch/ia64/mm/init.c
index e3215ba64ffd..b38b6d213c15 100644
--- a/arch/ia64/mm/init.c
+++ b/arch/ia64/mm/init.c
@@ -635,3 +635,39 @@ mem_init (void)
         ia32_mem_init();
 #endif
 }
+
+#ifdef CONFIG_MEMORY_HOTPLUG
+void online_page(struct page *page)
+{
+        ClearPageReserved(page);
+        set_page_count(page, 1);
+        __free_page(page);
+        totalram_pages++;
+        num_physpages++;
+}
+
+int add_memory(u64 start, u64 size)
+{
+        pg_data_t *pgdat;
+        struct zone *zone;
+        unsigned long start_pfn = start >> PAGE_SHIFT;
+        unsigned long nr_pages = size >> PAGE_SHIFT;
+        int ret;
+
+        pgdat = NODE_DATA(0);
+
+        zone = pgdat->node_zones + ZONE_NORMAL;
+        ret = __add_pages(zone, start_pfn, nr_pages);
+
+        if (ret)
+                printk("%s: Problem encountered in __add_pages() as ret=%d\n",
+                       __FUNCTION__,  ret);
+
+        return ret;
+}
+
+int remove_memory(u64 start, u64 size)
+{
+        return -EINVAL;
+}
+#endif
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/pci/pci.c b/arch/ia64/pci/pci.c
index 30dbc98bf0b3..d27ecdcb6fca 100644
--- a/arch/ia64/pci/pci.c
+++ b/arch/ia64/pci/pci.c
@@ -454,14 +454,13 @@ static int __devinit is_valid_resource(struct pci_dev *dev, int idx)
         return 0;
 }
 
-static void __devinit pcibios_fixup_device_resources(struct pci_dev *dev)
+static void __devinit
+pcibios_fixup_resources(struct pci_dev *dev, int start, int limit)
 {
         struct pci_bus_region region;
         int i;
-        int limit = (dev->hdr_type == PCI_HEADER_TYPE_NORMAL) ? \
-                PCI_BRIDGE_RESOURCES : PCI_NUM_RESOURCES;
 
-        for (i = 0; i < limit; i++) {
+        for (i = start; i < limit; i++) {
                 if (!dev->resource[i].flags)
                         continue;
                 region.start = dev->resource[i].start;
@@ -472,6 +471,16 @@ static void __devinit pcibios_fixup_device_resources(struct pci_dev *dev)
         }
 }
 
+static void __devinit pcibios_fixup_device_resources(struct pci_dev *dev)
+{
+        pcibios_fixup_resources(dev, 0, PCI_BRIDGE_RESOURCES);
+}
+
+static void __devinit pcibios_fixup_bridge_resources(struct pci_dev *dev)
+{
+        pcibios_fixup_resources(dev, PCI_BRIDGE_RESOURCES, PCI_NUM_RESOURCES);
+}
+
 /*
  *  Called after each bus is probed, but before its children are examined.
  */
@@ -482,7 +491,7 @@ pcibios_fixup_bus (struct pci_bus *b)
 
         if (b->self) {
                 pci_read_bridge_bases(b);
-                pcibios_fixup_device_resources(b->self);
+                pcibios_fixup_bridge_resources(b->self);
         }
         list_for_each_entry(dev, &b->devices, bus_list)
                 pcibios_fixup_device_resources(dev);
diff --git a/arch/ia64/sn/include/xtalk/hubdev.h b/arch/ia64/sn/include/xtalk/hubdev.h
index 71c2b271b4c6..7c88e9a58516 100644
--- a/arch/ia64/sn/include/xtalk/hubdev.h
+++ b/arch/ia64/sn/include/xtalk/hubdev.h
@@ -26,29 +26,37 @@
 #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];
         unsigned long sfdl_force_int_addr;
         unsigned long sfdl_flush_value;
         volatile unsigned long *sfdl_flush_addr;
-        uint32_t sfdl_persistent_busnum;
-        uint32_t sfdl_persistent_segment;
+        u32 sfdl_persistent_busnum;
+        u32 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 */
-        uint64_t iio_itte[8];
+        struct sn_flush_device_kernel **widget_p; // Used as an array of wid_num
+        u64 iio_itte[8];
 };
 
 struct hubdev_info {
@@ -62,8 +70,8 @@ struct hubdev_info {
 
         void                            *hdi_nodepda;
         void                            *hdi_node_vertex;
-        uint32_t                        max_segment_number;
-        uint32_t                        max_pcibus_number;
+        u32                             max_segment_number;
+        u32                             max_pcibus_number;
 };
 
 extern void hubdev_init_node(nodepda_t *, cnodeid_t);
diff --git a/arch/ia64/sn/include/xtalk/xbow.h b/arch/ia64/sn/include/xtalk/xbow.h
index ec56b3432f17..90f37a4133d0 100644
--- a/arch/ia64/sn/include/xtalk/xbow.h
+++ b/arch/ia64/sn/include/xtalk/xbow.h
@@ -3,7 +3,8 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (C) 1992-1997,2000-2004 Silicon Graphics, Inc. All Rights Reserved.
+ * Copyright (C) 1992-1997,2000-2006 Silicon Graphics, Inc. All Rights
+ * Reserved.
  */
 #ifndef _ASM_IA64_SN_XTALK_XBOW_H
 #define _ASM_IA64_SN_XTALK_XBOW_H
@@ -21,94 +22,94 @@
 
 /* Register set for each xbow link */
 typedef volatile struct xb_linkregs_s {
-/* 
+/*
  * we access these through synergy unswizzled space, so the address
  * gets twiddled (i.e. references to 0x4 actually go to 0x0 and vv.)
  * That's why we put the register first and filler second.
  */
-    uint32_t               link_ibf;
-    uint32_t               filler0;     /* filler for proper alignment */
-    uint32_t               link_control;
-    uint32_t               filler1;
-    uint32_t               link_status;
-    uint32_t               filler2;
-    uint32_t               link_arb_upper;
-    uint32_t               filler3;
-    uint32_t               link_arb_lower;
-    uint32_t               filler4;
-    uint32_t               link_status_clr;
-    uint32_t               filler5;
-    uint32_t               link_reset;
-    uint32_t               filler6;
-    uint32_t               link_aux_status;
-    uint32_t               filler7;
+        u32 link_ibf;
+        u32 filler0;    /* filler for proper alignment */
+        u32 link_control;
+        u32 filler1;
+        u32 link_status;
+        u32 filler2;
+        u32 link_arb_upper;
+        u32 filler3;
+        u32 link_arb_lower;
+        u32 filler4;
+        u32 link_status_clr;
+        u32 filler5;
+        u32 link_reset;
+        u32 filler6;
+        u32 link_aux_status;
+        u32 filler7;
 } xb_linkregs_t;
 
 typedef volatile struct xbow_s {
-    /* standard widget configuration                       0x000000-0x000057 */
-    struct widget_cfg            xb_widget;  /* 0x000000 */
-
-    /* helper fieldnames for accessing bridge widget */
-
-#define xb_wid_id                       xb_widget.w_id
-#define xb_wid_stat                     xb_widget.w_status
-#define xb_wid_err_upper                xb_widget.w_err_upper_addr
-#define xb_wid_err_lower                xb_widget.w_err_lower_addr
-#define xb_wid_control                  xb_widget.w_control
-#define xb_wid_req_timeout              xb_widget.w_req_timeout
-#define xb_wid_int_upper                xb_widget.w_intdest_upper_addr
-#define xb_wid_int_lower                xb_widget.w_intdest_lower_addr
-#define xb_wid_err_cmdword              xb_widget.w_err_cmd_word
-#define xb_wid_llp                      xb_widget.w_llp_cfg
-#define xb_wid_stat_clr                 xb_widget.w_tflush
-
-/* 
+        /* standard widget configuration 0x000000-0x000057 */
+        struct widget_cfg xb_widget;  /* 0x000000 */
+
+        /* helper fieldnames for accessing bridge widget */
+
+#define xb_wid_id               xb_widget.w_id
+#define xb_wid_stat             xb_widget.w_status
+#define xb_wid_err_upper        xb_widget.w_err_upper_addr
+#define xb_wid_err_lower        xb_widget.w_err_lower_addr
+#define xb_wid_control          xb_widget.w_control
+#define xb_wid_req_timeout      xb_widget.w_req_timeout
+#define xb_wid_int_upper        xb_widget.w_intdest_upper_addr
+#define xb_wid_int_lower        xb_widget.w_intdest_lower_addr
+#define xb_wid_err_cmdword      xb_widget.w_err_cmd_word
+#define xb_wid_llp              xb_widget.w_llp_cfg
+#define xb_wid_stat_clr         xb_widget.w_tflush
+
+/*
  * we access these through synergy unswizzled space, so the address
  * gets twiddled (i.e. references to 0x4 actually go to 0x0 and vv.)
  * That's why we put the register first and filler second.
  */
-    /* xbow-specific widget configuration                  0x000058-0x0000FF */
-    uint32_t               xb_wid_arb_reload;  /* 0x00005C */
-    uint32_t               _pad_000058;
-    uint32_t               xb_perf_ctr_a;      /* 0x000064 */
-    uint32_t               _pad_000060;
-    uint32_t               xb_perf_ctr_b;      /* 0x00006c */
-    uint32_t               _pad_000068;
-    uint32_t               xb_nic;     /* 0x000074 */
-    uint32_t               _pad_000070;
-
-    /* Xbridge only */
-    uint32_t               xb_w0_rst_fnc;      /* 0x00007C */
-    uint32_t               _pad_000078;
-    uint32_t               xb_l8_rst_fnc;      /* 0x000084 */
-    uint32_t               _pad_000080;
-    uint32_t               xb_l9_rst_fnc;      /* 0x00008c */
-    uint32_t               _pad_000088;
-    uint32_t               xb_la_rst_fnc;      /* 0x000094 */
-    uint32_t               _pad_000090;
-    uint32_t               xb_lb_rst_fnc;      /* 0x00009c */
-    uint32_t               _pad_000098;
-    uint32_t               xb_lc_rst_fnc;      /* 0x0000a4 */
-    uint32_t               _pad_0000a0;
-    uint32_t               xb_ld_rst_fnc;      /* 0x0000ac */
-    uint32_t               _pad_0000a8;
-    uint32_t               xb_le_rst_fnc;      /* 0x0000b4 */
-    uint32_t               _pad_0000b0;
-    uint32_t               xb_lf_rst_fnc;      /* 0x0000bc */
-    uint32_t               _pad_0000b8;
-    uint32_t               xb_lock;            /* 0x0000c4 */
-    uint32_t               _pad_0000c0;
-    uint32_t               xb_lock_clr;        /* 0x0000cc */
-    uint32_t               _pad_0000c8;
-    /* end of Xbridge only */
-    uint32_t               _pad_0000d0[12];
-
-    /* Link Specific Registers, port 8..15                 0x000100-0x000300 */
-    xb_linkregs_t           xb_link_raw[MAX_XBOW_PORTS];
-#define xb_link(p)      xb_link_raw[(p) & (MAX_XBOW_PORTS - 1)]
-
+        /* xbow-specific widget configuration    0x000058-0x0000FF */
+        u32 xb_wid_arb_reload; /* 0x00005C */
+        u32 _pad_000058;
+        u32 xb_perf_ctr_a;      /* 0x000064 */
+        u32 _pad_000060;
+        u32 xb_perf_ctr_b;      /* 0x00006c */
+        u32 _pad_000068;
+        u32 xb_nic;             /* 0x000074 */
+        u32 _pad_000070;
+
+        /* Xbridge only */
+        u32 xb_w0_rst_fnc;      /* 0x00007C */
+        u32 _pad_000078;
+        u32 xb_l8_rst_fnc;      /* 0x000084 */
+        u32 _pad_000080;
+        u32 xb_l9_rst_fnc;      /* 0x00008c */
+        u32 _pad_000088;
+        u32 xb_la_rst_fnc;      /* 0x000094 */
+        u32 _pad_000090;
+        u32 xb_lb_rst_fnc;      /* 0x00009c */
+        u32 _pad_000098;
+        u32 xb_lc_rst_fnc;      /* 0x0000a4 */
+        u32 _pad_0000a0;
+        u32 xb_ld_rst_fnc;      /* 0x0000ac */
+        u32 _pad_0000a8;
+        u32 xb_le_rst_fnc;      /* 0x0000b4 */
+        u32 _pad_0000b0;
+        u32 xb_lf_rst_fnc;      /* 0x0000bc */
+        u32 _pad_0000b8;
+        u32 xb_lock;            /* 0x0000c4 */
+        u32 _pad_0000c0;
+        u32 xb_lock_clr;        /* 0x0000cc */
+        u32 _pad_0000c8;
+        /* end of Xbridge only */
+        u32 _pad_0000d0[12];
+
+        /* Link Specific Registers, port 8..15   0x000100-0x000300 */
+        xb_linkregs_t xb_link_raw[MAX_XBOW_PORTS];
 } xbow_t;
 
+#define xb_link(p) xb_link_raw[(p) & (MAX_XBOW_PORTS - 1)]
+
 #define XB_FLAGS_EXISTS         0x1     /* device exists */
 #define XB_FLAGS_MASTER         0x2
 #define XB_FLAGS_SLAVE          0x0
@@ -160,7 +161,7 @@ typedef volatile struct xbow_s {
 /* End of Xbridge only */
 
 /* used only in ide, but defined here within the reserved portion */
-/*              of the widget0 address space (before 0xf4) */
+/* of the widget0 address space (before 0xf4) */
 #define XBOW_WID_UNDEF          0xe4
 
 /* xbow link register set base, legal value for x is 0x8..0xf */
@@ -179,29 +180,37 @@ typedef volatile struct xbow_s {
 
 /* link_control(x) */
 #define XB_CTRL_LINKALIVE_IE            0x80000000      /* link comes alive */
-     /* reserved:                       0x40000000 */
+/* reserved:                    0x40000000 */
 #define XB_CTRL_PERF_CTR_MODE_MSK       0x30000000      /* perf counter mode */
-#define XB_CTRL_IBUF_LEVEL_MSK          0x0e000000      /* input packet buffer level */
-#define XB_CTRL_8BIT_MODE               0x01000000      /* force link into 8 bit mode */
-#define XB_CTRL_BAD_LLP_PKT             0x00800000      /* force bad LLP packet */
-#define XB_CTRL_WIDGET_CR_MSK           0x007c0000      /* LLP widget credit mask */
-#define XB_CTRL_WIDGET_CR_SHFT  18                      /* LLP widget credit shift */
-#define XB_CTRL_ILLEGAL_DST_IE          0x00020000      /* illegal destination */
-#define XB_CTRL_OALLOC_IBUF_IE          0x00010000      /* overallocated input buffer */
-     /* reserved:                       0x0000fe00 */
+#define XB_CTRL_IBUF_LEVEL_MSK          0x0e000000      /* input packet buffer
+                                                           level */
+#define XB_CTRL_8BIT_MODE               0x01000000      /* force link into 8
+                                                           bit mode */
+#define XB_CTRL_BAD_LLP_PKT             0x00800000      /* force bad LLP
+                                                           packet */
+#define XB_CTRL_WIDGET_CR_MSK           0x007c0000      /* LLP widget credit
+                                                           mask */
+#define XB_CTRL_WIDGET_CR_SHFT  18                      /* LLP widget credit
+                                                           shift */
+#define XB_CTRL_ILLEGAL_DST_IE          0x00020000      /* illegal destination
+                                                         */
+#define XB_CTRL_OALLOC_IBUF_IE          0x00010000      /* overallocated input
+                                                           buffer */
+/* reserved:                    0x0000fe00 */
 #define XB_CTRL_BNDWDTH_ALLOC_IE        0x00000100      /* bandwidth alloc */
 #define XB_CTRL_RCV_CNT_OFLOW_IE        0x00000080      /* rcv retry overflow */
 #define XB_CTRL_XMT_CNT_OFLOW_IE        0x00000040      /* xmt retry overflow */
 #define XB_CTRL_XMT_MAX_RTRY_IE         0x00000020      /* max transmit retry */
 #define XB_CTRL_RCV_IE                  0x00000010      /* receive */
 #define XB_CTRL_XMT_RTRY_IE             0x00000008      /* transmit retry */
-     /* reserved:                       0x00000004 */
-#define XB_CTRL_MAXREQ_TOUT_IE          0x00000002      /* maximum request timeout */
+/* reserved:                    0x00000004 */
+#define XB_CTRL_MAXREQ_TOUT_IE          0x00000002      /* maximum request
+                                                           timeout */
 #define XB_CTRL_SRC_TOUT_IE             0x00000001      /* source timeout */
 
 /* link_status(x) */
 #define XB_STAT_LINKALIVE               XB_CTRL_LINKALIVE_IE
-     /* reserved:                       0x7ff80000 */
+/* reserved:                    0x7ff80000 */
 #define XB_STAT_MULTI_ERR               0x00040000      /* multi error */
 #define XB_STAT_ILLEGAL_DST_ERR         XB_CTRL_ILLEGAL_DST_IE
 #define XB_STAT_OALLOC_IBUF_ERR         XB_CTRL_OALLOC_IBUF_IE
@@ -211,7 +220,7 @@ typedef volatile struct xbow_s {
 #define XB_STAT_XMT_MAX_RTRY_ERR        XB_CTRL_XMT_MAX_RTRY_IE
 #define XB_STAT_RCV_ERR                 XB_CTRL_RCV_IE
 #define XB_STAT_XMT_RTRY_ERR            XB_CTRL_XMT_RTRY_IE
-     /* reserved:                       0x00000004 */
+/* reserved:                    0x00000004 */
 #define XB_STAT_MAXREQ_TOUT_ERR         XB_CTRL_MAXREQ_TOUT_IE
 #define XB_STAT_SRC_TOUT_ERR            XB_CTRL_SRC_TOUT_IE
 
@@ -222,7 +231,7 @@ typedef volatile struct xbow_s {
 #define XB_AUX_LINKFAIL_RST_BAD 0x00000040
 #define XB_AUX_STAT_PRESENT     0x00000020
 #define XB_AUX_STAT_PORT_WIDTH  0x00000010
-     /* reserved:               0x0000000f */
+/*      reserved:               0x0000000f */
 
 /*
  * link_arb_upper/link_arb_lower(x), (reg) should be the link_arb_upper
@@ -238,7 +247,8 @@ typedef volatile struct xbow_s {
 /* XBOW_WID_STAT */
 #define XB_WID_STAT_LINK_INTR_SHFT      (24)
 #define XB_WID_STAT_LINK_INTR_MASK      (0xFF << XB_WID_STAT_LINK_INTR_SHFT)
-#define XB_WID_STAT_LINK_INTR(x)        (0x1 << (((x)&7) + XB_WID_STAT_LINK_INTR_SHFT))
+#define XB_WID_STAT_LINK_INTR(x) \
+        (0x1 << (((x)&7) + XB_WID_STAT_LINK_INTR_SHFT))
 #define XB_WID_STAT_WIDGET0_INTR        0x00800000
 #define XB_WID_STAT_SRCID_MASK          0x000003c0      /* Xbridge only */
 #define XB_WID_STAT_REG_ACC_ERR         0x00000020
@@ -264,7 +274,7 @@ typedef volatile struct xbow_s {
 #define XXBOW_WIDGET_PART_NUM   0xd000          /* Xbridge */
 #define XBOW_WIDGET_MFGR_NUM    0x0
 #define XXBOW_WIDGET_MFGR_NUM   0x0
-#define PXBOW_WIDGET_PART_NUM   0xd100          /* PIC */
+#define PXBOW_WIDGET_PART_NUM   0xd100          /* PIC */
 
 #define XBOW_REV_1_0            0x1     /* xbow rev 1.0 is "1" */
 #define XBOW_REV_1_1            0x2     /* xbow rev 1.1 is "2" */
@@ -279,13 +289,13 @@ typedef volatile struct xbow_s {
 #define XBOW_WID_ARB_RELOAD_INT 0x3f    /* GBR reload interval */
 
 #define IS_XBRIDGE_XBOW(wid) \
-        (XWIDGET_PART_NUM(wid) == XXBOW_WIDGET_PART_NUM && \
-                        XWIDGET_MFG_NUM(wid) == XXBOW_WIDGET_MFGR_NUM)
+        (XWIDGET_PART_NUM(wid) == XXBOW_WIDGET_PART_NUM && \
+        XWIDGET_MFG_NUM(wid) == XXBOW_WIDGET_MFGR_NUM)
 
 #define IS_PIC_XBOW(wid) \
-        (XWIDGET_PART_NUM(wid) == PXBOW_WIDGET_PART_NUM && \
-                        XWIDGET_MFG_NUM(wid) == XXBOW_WIDGET_MFGR_NUM)
+        (XWIDGET_PART_NUM(wid) == PXBOW_WIDGET_PART_NUM && \
+        XWIDGET_MFG_NUM(wid) == XXBOW_WIDGET_MFGR_NUM)
 
 #define XBOW_WAR_ENABLED(pv, widid) ((1 << XWIDGET_REV_NUM(widid)) & pv)
 
-#endif                          /* _ASM_IA64_SN_XTALK_XBOW_H */
+#endif /* _ASM_IA64_SN_XTALK_XBOW_H */
diff --git a/arch/ia64/sn/include/xtalk/xwidgetdev.h b/arch/ia64/sn/include/xtalk/xwidgetdev.h
index c5f4bc5cc033..2800eda0fd68 100644
--- a/arch/ia64/sn/include/xtalk/xwidgetdev.h
+++ b/arch/ia64/sn/include/xtalk/xwidgetdev.h
@@ -25,28 +25,28 @@
 
 /* widget configuration registers */
 struct widget_cfg{
-        uint32_t        w_id;   /* 0x04 */
-        uint32_t        w_pad_0;        /* 0x00 */
-        uint32_t        w_status;       /* 0x0c */
-        uint32_t        w_pad_1;        /* 0x08 */
-        uint32_t        w_err_upper_addr;       /* 0x14 */
-        uint32_t        w_pad_2;        /* 0x10 */
-        uint32_t        w_err_lower_addr;       /* 0x1c */
-        uint32_t        w_pad_3;        /* 0x18 */
-        uint32_t        w_control;      /* 0x24 */
-        uint32_t        w_pad_4;        /* 0x20 */
-        uint32_t        w_req_timeout;  /* 0x2c */
-        uint32_t        w_pad_5;        /* 0x28 */
-        uint32_t        w_intdest_upper_addr;   /* 0x34 */
-        uint32_t        w_pad_6;        /* 0x30 */
-        uint32_t        w_intdest_lower_addr;   /* 0x3c */
-        uint32_t        w_pad_7;        /* 0x38 */
-        uint32_t        w_err_cmd_word; /* 0x44 */
-        uint32_t        w_pad_8;        /* 0x40 */
-        uint32_t        w_llp_cfg;      /* 0x4c */
-        uint32_t        w_pad_9;        /* 0x48 */
-        uint32_t        w_tflush;       /* 0x54 */
-        uint32_t        w_pad_10;       /* 0x50 */
+        u32     w_id;   /* 0x04 */
+        u32     w_pad_0;        /* 0x00 */
+        u32     w_status;       /* 0x0c */
+        u32     w_pad_1;        /* 0x08 */
+        u32     w_err_upper_addr;       /* 0x14 */
+        u32     w_pad_2;        /* 0x10 */
+        u32     w_err_lower_addr;       /* 0x1c */
+        u32     w_pad_3;        /* 0x18 */
+        u32     w_control;      /* 0x24 */
+        u32     w_pad_4;        /* 0x20 */
+        u32     w_req_timeout;  /* 0x2c */
+        u32     w_pad_5;        /* 0x28 */
+        u32     w_intdest_upper_addr;   /* 0x34 */
+        u32     w_pad_6;        /* 0x30 */
+        u32     w_intdest_lower_addr;   /* 0x3c */
+        u32     w_pad_7;        /* 0x38 */
+        u32     w_err_cmd_word; /* 0x44 */
+        u32     w_pad_8;        /* 0x40 */
+        u32     w_llp_cfg;      /* 0x4c */
+        u32     w_pad_9;        /* 0x48 */
+        u32     w_tflush;       /* 0x54 */
+        u32     w_pad_10;       /* 0x50 */
 };
 
 /*
@@ -63,7 +63,7 @@ struct xwidget_info{
         struct xwidget_hwid     xwi_hwid;       /* Widget Identification */
         char                    xwi_masterxid;  /* Hub's Widget Port Number */
         void                    *xwi_hubinfo;     /* Hub's provider private info */
-        uint64_t                *xwi_hub_provider; /* prom provider functions */
+        u64                     *xwi_hub_provider; /* prom provider functions */
         void                    *xwi_vertex;
 };
 
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..233d55115d33 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,9 +131,9 @@ 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
-sal_get_pcidev_info(u64 segment, u64 bus_number, u64 devfn, u64 pci_dev, 
-                        u64 sn_irq_info)
+static inline u64
+sal_get_pcidev_info(u64 segment, u64 bus_number, u64 devfn, u64 pci_dev,
+                    u64 sn_irq_info)
 {
         struct ia64_sal_retval ret_stuff;
         ret_stuff.status = 0;
@@ -140,7 +141,7 @@ sal_get_pcidev_info(u64 segment, u64 bus_number, u64 devfn, u64 pci_dev,
 
         SAL_CALL_NOLOCK(ret_stuff,
                         (u64) SN_SAL_IOIF_GET_PCIDEV_INFO,
-                        (u64) segment, (u64) bus_number, (u64) devfn, 
+                        (u64) segment, (u64) bus_number, (u64) devfn,
                         (u64) pci_dev,
                         sn_irq_info, 0, 0);
         return ret_stuff.v0;
@@ -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;
+                }
         }
-
 }
 
 /*
@@ -256,7 +268,7 @@ static void sn_fixup_ionodes(void)
  */
 static void
 sn_pci_window_fixup(struct pci_dev *dev, unsigned int count,
-                    int64_t * pci_addrs)
+                    s64 * pci_addrs)
 {
         struct pci_controller *controller = PCI_CONTROLLER(dev->bus);
         unsigned int i;
@@ -316,7 +328,7 @@ void sn_pci_fixup_slot(struct pci_dev *dev)
         struct pci_bus *host_pci_bus;
         struct pci_dev *host_pci_dev;
         struct pcidev_info *pcidev_info;
-        int64_t pci_addrs[PCI_ROM_RESOURCE + 1];
+        s64 pci_addrs[PCI_ROM_RESOURCE + 1];
         struct sn_irq_info *sn_irq_info;
         unsigned long size;
         unsigned int bus_no, devfn;
diff --git a/arch/ia64/sn/kernel/irq.c b/arch/ia64/sn/kernel/irq.c
index 01d18b7b5bb3..ec37084bdc17 100644
--- a/arch/ia64/sn/kernel/irq.c
+++ b/arch/ia64/sn/kernel/irq.c
@@ -28,7 +28,7 @@ extern int sn_ioif_inited;
 static struct list_head **sn_irq_lh;
 static spinlock_t sn_irq_info_lock = SPIN_LOCK_UNLOCKED; /* non-IRQ lock */
 
-static inline uint64_t sn_intr_alloc(nasid_t local_nasid, int local_widget,
+static inline u64 sn_intr_alloc(nasid_t local_nasid, int local_widget,
                                      u64 sn_irq_info,
                                      int req_irq, nasid_t req_nasid,
                                      int req_slice)
@@ -123,7 +123,7 @@ static void sn_set_affinity_irq(unsigned int irq, cpumask_t mask)
 
         list_for_each_entry_safe(sn_irq_info, sn_irq_info_safe,
                                  sn_irq_lh[irq], list) {
-                uint64_t bridge;
+                u64 bridge;
                 int local_widget, status;
                 nasid_t local_nasid;
                 struct sn_irq_info *new_irq_info;
@@ -134,7 +134,7 @@ static void sn_set_affinity_irq(unsigned int irq, cpumask_t mask)
                         break;
                 memcpy(new_irq_info, sn_irq_info, sizeof(struct sn_irq_info));
 
-                bridge = (uint64_t) new_irq_info->irq_bridge;
+                bridge = (u64) new_irq_info->irq_bridge;
                 if (!bridge) {
                         kfree(new_irq_info);
                         break; /* irq is not a device interrupt */
@@ -349,10 +349,10 @@ static void force_interrupt(int irq)
  */
 static void sn_check_intr(int irq, struct sn_irq_info *sn_irq_info)
 {
-        uint64_t regval;
+        u64 regval;
         int irr_reg_num;
         int irr_bit;
-        uint64_t irr_reg;
+        u64 irr_reg;
         struct pcidev_info *pcidev_info;
         struct pcibus_info *pcibus_info;
 
diff --git a/arch/ia64/sn/kernel/tiocx.c b/arch/ia64/sn/kernel/tiocx.c
index 493fb3f38dc3..d263d3e8fbb9 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);
 }
@@ -245,7 +245,7 @@ static int cx_device_reload(struct cx_dev *cx_dev)
                                   cx_dev->bt);
 }
 
-static inline uint64_t tiocx_intr_alloc(nasid_t nasid, int widget,
+static inline u64 tiocx_intr_alloc(nasid_t nasid, int widget,
                                         u64 sn_irq_info,
                                         int req_irq, nasid_t req_nasid,
                                         int req_slice)
@@ -302,7 +302,7 @@ struct sn_irq_info *tiocx_irq_alloc(nasid_t nasid, int widget, int irq,
 
 void tiocx_irq_free(struct sn_irq_info *sn_irq_info)
 {
-        uint64_t bridge = (uint64_t) sn_irq_info->irq_bridge;
+        u64 bridge = (u64) sn_irq_info->irq_bridge;
         nasid_t nasid = NASID_GET(bridge);
         int widget;
 
@@ -313,12 +313,12 @@ void tiocx_irq_free(struct sn_irq_info *sn_irq_info)
         }
 }
 
-uint64_t tiocx_dma_addr(uint64_t addr)
+u64 tiocx_dma_addr(u64 addr)
 {
         return PHYS_TO_TIODMA(addr);
 }
 
-uint64_t tiocx_swin_base(int nasid)
+u64 tiocx_swin_base(int nasid)
 {
         return TIO_SWIN_BASE(nasid, TIOCX_CORELET);
 }
@@ -335,8 +335,8 @@ EXPORT_SYMBOL(tiocx_swin_base);
 
 static void tio_conveyor_set(nasid_t nasid, int enable_flag)
 {
-        uint64_t ice_frz;
-        uint64_t disable_cb = (1ull << 61);
+        u64 ice_frz;
+        u64 disable_cb = (1ull << 61);
 
         if (!(nasid & 1))
                 return;
@@ -388,7 +388,7 @@ static int is_fpga_tio(int nasid, int *bt)
 
 static int bitstream_loaded(nasid_t nasid)
 {
-        uint64_t cx_credits;
+        u64 cx_credits;
 
         cx_credits = REMOTE_HUB_L(nasid, TIO_ICE_PMI_TX_DYN_CREDIT_STAT_CB3);
         cx_credits &= TIO_ICE_PMI_TX_DYN_CREDIT_STAT_CB3_CREDIT_CNT_MASK;
@@ -404,14 +404,14 @@ static int tiocx_reload(struct cx_dev *cx_dev)
         nasid_t nasid = cx_dev->cx_id.nasid;
 
         if (bitstream_loaded(nasid)) {
-                uint64_t cx_id;
+                u64 cx_id;
                 int rv;
 
                 rv = ia64_sn_sysctl_tio_clock_reset(nasid);
                 if (rv) {
                         printk(KERN_ALERT "CX port JTAG reset failed.\n");
                 } else {
-                        cx_id = *(volatile uint64_t *)
+                        cx_id = *(volatile u64 *)
                                 (TIO_SWIN_BASE(nasid, TIOCX_CORELET) +
                                           WIDGET_ID);
                         part_num = XWIDGET_PART_NUM(cx_id);
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_ate.c b/arch/ia64/sn/pci/pcibr/pcibr_ate.c
index d1647b863e61..aa3fa5152a32 100644
--- a/arch/ia64/sn/pci/pcibr/pcibr_ate.c
+++ b/arch/ia64/sn/pci/pcibr/pcibr_ate.c
@@ -18,10 +18,10 @@ int pcibr_invalidate_ate = 0;	/* by default don't invalidate ATE on free */
  * mark_ate: Mark the ate as either free or inuse.
  */
 static void mark_ate(struct ate_resource *ate_resource, int start, int number,
-                     uint64_t value)
+                     u64 value)
 {
 
-        uint64_t *ate = ate_resource->ate;
+        u64 *ate = ate_resource->ate;
         int index;
         int length = 0;
 
@@ -38,7 +38,7 @@ static int find_free_ate(struct ate_resource *ate_resource, int start,
                          int count)
 {
 
-        uint64_t *ate = ate_resource->ate;
+        u64 *ate = ate_resource->ate;
         int index;
         int start_free;
 
@@ -119,7 +119,7 @@ static inline int alloc_ate_resource(struct ate_resource *ate_resource,
 int pcibr_ate_alloc(struct pcibus_info *pcibus_info, int count)
 {
         int status = 0;
-        uint64_t flag;
+        u64 flag;
 
         flag = pcibr_lock(pcibus_info);
         status = alloc_ate_resource(&pcibus_info->pbi_int_ate_resource, count);
@@ -139,7 +139,7 @@ int pcibr_ate_alloc(struct pcibus_info *pcibus_info, int count)
  * Setup an Address Translation Entry as specified.  Use either the Bridge
  * internal maps or the external map RAM, as appropriate.
  */
-static inline uint64_t *pcibr_ate_addr(struct pcibus_info *pcibus_info,
+static inline u64 *pcibr_ate_addr(struct pcibus_info *pcibus_info,
                                        int ate_index)
 {
         if (ate_index < pcibus_info->pbi_int_ate_size) {
@@ -153,7 +153,7 @@ static inline uint64_t *pcibr_ate_addr(struct pcibus_info *pcibus_info,
  */
 void inline
 ate_write(struct pcibus_info *pcibus_info, int ate_index, int count,
-          volatile uint64_t ate)
+          volatile u64 ate)
 {
         while (count-- > 0) {
                 if (ate_index < pcibus_info->pbi_int_ate_size) {
@@ -171,9 +171,9 @@ ate_write(struct pcibus_info *pcibus_info, int ate_index, int count,
 void pcibr_ate_free(struct pcibus_info *pcibus_info, int index)
 {
 
-        volatile uint64_t ate;
+        volatile u64 ate;
         int count;
-        uint64_t flags;
+        u64 flags;
 
         if (pcibr_invalidate_ate) {
                 /* For debugging purposes, clear the valid bit in the ATE */
diff --git a/arch/ia64/sn/pci/pcibr/pcibr_dma.c b/arch/ia64/sn/pci/pcibr/pcibr_dma.c
index 34093476e965..54ce5b7ceed2 100644
--- a/arch/ia64/sn/pci/pcibr/pcibr_dma.c
+++ b/arch/ia64/sn/pci/pcibr/pcibr_dma.c
@@ -41,21 +41,21 @@ extern int sn_ioif_inited;
 
 static dma_addr_t
 pcibr_dmamap_ate32(struct pcidev_info *info,
-                   uint64_t paddr, size_t req_size, uint64_t flags)
+                   u64 paddr, size_t req_size, u64 flags)
 {
 
         struct pcidev_info *pcidev_info = info->pdi_host_pcidev_info;
         struct pcibus_info *pcibus_info = (struct pcibus_info *)pcidev_info->
             pdi_pcibus_info;
-        uint8_t internal_device = (PCI_SLOT(pcidev_info->pdi_host_pcidev_info->
+        u8 internal_device = (PCI_SLOT(pcidev_info->pdi_host_pcidev_info->
                                             pdi_linux_pcidev->devfn)) - 1;
         int ate_count;
         int ate_index;
-        uint64_t ate_flags = flags | PCI32_ATE_V;
-        uint64_t ate;
-        uint64_t pci_addr;
-        uint64_t xio_addr;
-        uint64_t offset;
+        u64 ate_flags = flags | PCI32_ATE_V;
+        u64 ate;
+        u64 pci_addr;
+        u64 xio_addr;
+        u64 offset;
 
         /* PIC in PCI-X mode does not supports 32bit PageMap mode */
         if (IS_PIC_SOFT(pcibus_info) && IS_PCIX(pcibus_info)) {
@@ -109,12 +109,12 @@ pcibr_dmamap_ate32(struct pcidev_info *info,
 }
 
 static dma_addr_t
-pcibr_dmatrans_direct64(struct pcidev_info * info, uint64_t paddr,
-                        uint64_t dma_attributes)
+pcibr_dmatrans_direct64(struct pcidev_info * info, u64 paddr,
+                        u64 dma_attributes)
 {
         struct pcibus_info *pcibus_info = (struct pcibus_info *)
             ((info->pdi_host_pcidev_info)->pdi_pcibus_info);
-        uint64_t pci_addr;
+        u64 pci_addr;
 
         /* Translate to Crosstalk View of Physical Address */
         pci_addr = (IS_PIC_SOFT(pcibus_info) ? PHYS_TO_DMA(paddr) :
@@ -127,7 +127,7 @@ pcibr_dmatrans_direct64(struct pcidev_info * info, uint64_t paddr,
         /* Handle Bridge Chipset differences */
         if (IS_PIC_SOFT(pcibus_info)) {
                 pci_addr |=
-                    ((uint64_t) pcibus_info->
+                    ((u64) pcibus_info->
                      pbi_hub_xid << PIC_PCI64_ATTR_TARG_SHFT);
         } else
                 pci_addr |= TIOCP_PCI64_CMDTYPE_MEM;
@@ -142,17 +142,17 @@ pcibr_dmatrans_direct64(struct pcidev_info * info, uint64_t paddr,
 
 static dma_addr_t
 pcibr_dmatrans_direct32(struct pcidev_info * info,
-                        uint64_t paddr, size_t req_size, uint64_t flags)
+                        u64 paddr, size_t req_size, u64 flags)
 {
 
         struct pcidev_info *pcidev_info = info->pdi_host_pcidev_info;
         struct pcibus_info *pcibus_info = (struct pcibus_info *)pcidev_info->
             pdi_pcibus_info;
-        uint64_t xio_addr;
+        u64 xio_addr;
 
-        uint64_t xio_base;
-        uint64_t offset;
-        uint64_t endoff;
+        u64 xio_base;
+        u64 offset;
+        u64 endoff;
 
         if (IS_PCIX(pcibus_info)) {
                 return 0;
@@ -209,16 +209,18 @@ pcibr_dma_unmap(struct pci_dev *hwdev, dma_addr_t dma_handle, int direction)
  * unlike the PIC Device(x) Write Request Buffer Flush register.
  */
 
-void sn_dma_flush(uint64_t addr)
+void sn_dma_flush(u64 addr)
 {
         nasid_t nasid;
         int is_tio;
         int wid_num;
         int i, j;
-        uint64_t flags;
-        uint64_t itte;
+        u64 flags;
+        u64 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. */
@@ -297,31 +299,31 @@ void sn_dma_flush(uint64_t addr)
                  * If CE ever needs the sn_dma_flush mechanism, we will have
                  * to account for that here and in tioce_bus_fixup().
                  */
-                uint32_t tio_id = HUB_L(TIO_IOSPACE_ADDR(nasid, TIO_NODE_ID));
-                uint32_t revnum = XWIDGET_PART_REV_NUM(tio_id);
+                u32 tio_id = HUB_L(TIO_IOSPACE_ADDR(nasid, TIO_NODE_ID));
+                u32 revnum = XWIDGET_PART_REV_NUM(tio_id);
 
                 /* TIOCP BRINGUP WAR (PV907516): Don't write buffer flush reg */
                 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 u32 *)(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..77a1262751d3 100644
--- a/arch/ia64/sn/pci/pcibr/pcibr_provider.c
+++ b/arch/ia64/sn/pci/pcibr/pcibr_provider.c
@@ -23,7 +23,7 @@ int
 sal_pcibr_slot_enable(struct pcibus_info *soft, int device, void *resp)
 {
         struct ia64_sal_retval ret_stuff;
-        uint64_t busnum;
+        u64 busnum;
 
         ret_stuff.status = 0;
         ret_stuff.v0 = 0;
@@ -40,7 +40,7 @@ sal_pcibr_slot_disable(struct pcibus_info *soft, int device, int action,
                        void *resp)
 {
         struct ia64_sal_retval ret_stuff;
-        uint64_t busnum;
+        u64 busnum;
 
         ret_stuff.status = 0;
         ret_stuff.v0 = 0;
@@ -56,7 +56,7 @@ sal_pcibr_slot_disable(struct pcibus_info *soft, int device, int action,
 static int sal_pcibr_error_interrupt(struct pcibus_info *soft)
 {
         struct ia64_sal_retval ret_stuff;
-        uint64_t busnum;
+        u64 busnum;
         int segment;
         ret_stuff.status = 0;
         ret_stuff.v0 = 0;
@@ -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;
                         }
                 }
@@ -159,9 +159,9 @@ pcibr_bus_fixup(struct pcibus_bussoft *prom_bussoft, struct pci_controller *cont
         /* Setup the PMU ATE map */
         soft->pbi_int_ate_resource.lowest_free_index = 0;
         soft->pbi_int_ate_resource.ate =
-            kmalloc(soft->pbi_int_ate_size * sizeof(uint64_t), GFP_KERNEL);
+            kmalloc(soft->pbi_int_ate_size * sizeof(u64), GFP_KERNEL);
         memset(soft->pbi_int_ate_resource.ate, 0,
-               (soft->pbi_int_ate_size * sizeof(uint64_t)));
+               (soft->pbi_int_ate_size * sizeof(u64)));
 
         if (prom_bussoft->bs_asic_type == PCIIO_ASIC_TYPE_TIOCP) {
                 /* TIO PCI Bridge: find nearest node with CPUs */
@@ -203,7 +203,7 @@ void pcibr_target_interrupt(struct sn_irq_info *sn_irq_info)
         struct pcidev_info *pcidev_info;
         struct pcibus_info *pcibus_info;
         int bit = sn_irq_info->irq_int_bit;
-        uint64_t xtalk_addr = sn_irq_info->irq_xtalkaddr;
+        u64 xtalk_addr = sn_irq_info->irq_xtalkaddr;
 
         pcidev_info = (struct pcidev_info *)sn_irq_info->irq_pciioinfo;
         if (pcidev_info) {
diff --git a/arch/ia64/sn/pci/pcibr/pcibr_reg.c b/arch/ia64/sn/pci/pcibr/pcibr_reg.c
index 79fdb91d7259..8b8bbd51d433 100644
--- a/arch/ia64/sn/pci/pcibr/pcibr_reg.c
+++ b/arch/ia64/sn/pci/pcibr/pcibr_reg.c
@@ -23,7 +23,7 @@ union br_ptr {
 /*
  * Control Register Access -- Read/Write                            0000_0020
  */
-void pcireg_control_bit_clr(struct pcibus_info *pcibus_info, uint64_t bits)
+void pcireg_control_bit_clr(struct pcibus_info *pcibus_info, u64 bits)
 {
         union br_ptr __iomem *ptr = (union br_ptr __iomem *)pcibus_info->pbi_buscommon.bs_base;
 
@@ -43,7 +43,7 @@ void pcireg_control_bit_clr(struct pcibus_info *pcibus_info, uint64_t bits)
         }
 }
 
-void pcireg_control_bit_set(struct pcibus_info *pcibus_info, uint64_t bits)
+void pcireg_control_bit_set(struct pcibus_info *pcibus_info, u64 bits)
 {
         union br_ptr __iomem *ptr = (union br_ptr __iomem *)pcibus_info->pbi_buscommon.bs_base;
 
@@ -66,10 +66,10 @@ void pcireg_control_bit_set(struct pcibus_info *pcibus_info, uint64_t bits)
 /*
  * PCI/PCIX Target Flush Register Access -- Read Only               0000_0050
  */
-uint64_t pcireg_tflush_get(struct pcibus_info *pcibus_info)
+u64 pcireg_tflush_get(struct pcibus_info *pcibus_info)
 {
         union br_ptr __iomem *ptr = (union br_ptr __iomem *)pcibus_info->pbi_buscommon.bs_base;
-        uint64_t ret = 0;
+        u64 ret = 0;
 
         if (pcibus_info) {
                 switch (pcibus_info->pbi_bridge_type) {
@@ -96,10 +96,10 @@ uint64_t pcireg_tflush_get(struct pcibus_info *pcibus_info)
 /*
  * Interrupt Status Register Access -- Read Only                    0000_0100
  */
-uint64_t pcireg_intr_status_get(struct pcibus_info * pcibus_info)
+u64 pcireg_intr_status_get(struct pcibus_info * pcibus_info)
 {
         union br_ptr __iomem *ptr = (union br_ptr __iomem *)pcibus_info->pbi_buscommon.bs_base;
-        uint64_t ret = 0;
+        u64 ret = 0;
 
         if (pcibus_info) {
                 switch (pcibus_info->pbi_bridge_type) {
@@ -121,7 +121,7 @@ uint64_t pcireg_intr_status_get(struct pcibus_info * pcibus_info)
 /*
  * Interrupt Enable Register Access -- Read/Write                   0000_0108
  */
-void pcireg_intr_enable_bit_clr(struct pcibus_info *pcibus_info, uint64_t bits)
+void pcireg_intr_enable_bit_clr(struct pcibus_info *pcibus_info, u64 bits)
 {
         union br_ptr __iomem *ptr = (union br_ptr __iomem *)pcibus_info->pbi_buscommon.bs_base;
 
@@ -141,7 +141,7 @@ void pcireg_intr_enable_bit_clr(struct pcibus_info *pcibus_info, uint64_t bits)
         }
 }
 
-void pcireg_intr_enable_bit_set(struct pcibus_info *pcibus_info, uint64_t bits)
+void pcireg_intr_enable_bit_set(struct pcibus_info *pcibus_info, u64 bits)
 {
         union br_ptr __iomem *ptr = (union br_ptr __iomem *)pcibus_info->pbi_buscommon.bs_base;
 
@@ -165,7 +165,7 @@ void pcireg_intr_enable_bit_set(struct pcibus_info *pcibus_info, uint64_t bits)
  * Intr Host Address Register (int_addr) -- Read/Write  0000_0130 - 0000_0168
  */
 void pcireg_intr_addr_addr_set(struct pcibus_info *pcibus_info, int int_n,
-                               uint64_t addr)
+                               u64 addr)
 {
         union br_ptr __iomem *ptr = (union br_ptr __iomem *)pcibus_info->pbi_buscommon.bs_base;
 
@@ -217,10 +217,10 @@ void pcireg_force_intr_set(struct pcibus_info *pcibus_info, int int_n)
 /*
  * Device(x) Write Buffer Flush Reg Access -- Read Only 0000_0240 - 0000_0258
  */
-uint64_t pcireg_wrb_flush_get(struct pcibus_info *pcibus_info, int device)
+u64 pcireg_wrb_flush_get(struct pcibus_info *pcibus_info, int device)
 {
         union br_ptr __iomem *ptr = (union br_ptr __iomem *)pcibus_info->pbi_buscommon.bs_base;
-        uint64_t ret = 0;
+        u64 ret = 0;
 
         if (pcibus_info) {
                 switch (pcibus_info->pbi_bridge_type) {
@@ -242,7 +242,7 @@ uint64_t pcireg_wrb_flush_get(struct pcibus_info *pcibus_info, int device)
 }
 
 void pcireg_int_ate_set(struct pcibus_info *pcibus_info, int ate_index,
-                        uint64_t val)
+                        u64 val)
 {
         union br_ptr __iomem *ptr = (union br_ptr __iomem *)pcibus_info->pbi_buscommon.bs_base;
 
@@ -262,10 +262,10 @@ void pcireg_int_ate_set(struct pcibus_info *pcibus_info, int ate_index,
         }
 }
 
-uint64_t __iomem *pcireg_int_ate_addr(struct pcibus_info *pcibus_info, int ate_index)
+u64 __iomem *pcireg_int_ate_addr(struct pcibus_info *pcibus_info, int ate_index)
 {
         union br_ptr __iomem *ptr = (union br_ptr __iomem *)pcibus_info->pbi_buscommon.bs_base;
-        uint64_t __iomem *ret = NULL;
+        u64 __iomem *ret = NULL;
 
         if (pcibus_info) {
                 switch (pcibus_info->pbi_bridge_type) {
diff --git a/arch/ia64/sn/pci/tioca_provider.c b/arch/ia64/sn/pci/tioca_provider.c
index 27aa1842dacc..7571a4025529 100644
--- a/arch/ia64/sn/pci/tioca_provider.c
+++ b/arch/ia64/sn/pci/tioca_provider.c
@@ -16,7 +16,7 @@
 #include <asm/sn/pcibus_provider_defs.h>
 #include <asm/sn/tioca_provider.h>
 
-uint32_t tioca_gart_found;
+u32 tioca_gart_found;
 EXPORT_SYMBOL(tioca_gart_found);        /* used by agp-sgi */
 
 LIST_HEAD(tioca_list);
@@ -34,8 +34,8 @@ static int tioca_gart_init(struct tioca_kernel *);
 static int
 tioca_gart_init(struct tioca_kernel *tioca_kern)
 {
-        uint64_t ap_reg;
-        uint64_t offset;
+        u64 ap_reg;
+        u64 offset;
         struct page *tmp;
         struct tioca_common *tioca_common;
         struct tioca __iomem *ca_base;
@@ -214,7 +214,7 @@ void
 tioca_fastwrite_enable(struct tioca_kernel *tioca_kern)
 {
         int cap_ptr;
-        uint32_t reg;
+        u32 reg;
         struct tioca __iomem *tioca_base;
         struct pci_dev *pdev;
         struct tioca_common *common;
@@ -276,7 +276,7 @@ EXPORT_SYMBOL(tioca_fastwrite_enable);	/* used by agp-sgi */
  *                                 We will always use 0x1
  * 55:55 - Swap bytes              Currently unused
  */
-static uint64_t
+static u64
 tioca_dma_d64(unsigned long paddr)
 {
         dma_addr_t bus_addr;
@@ -318,15 +318,15 @@ tioca_dma_d64(unsigned long paddr)
  * and so a given CA can only directly target nodes in the range
  * xxx - xxx+255.
  */
-static uint64_t
-tioca_dma_d48(struct pci_dev *pdev, uint64_t paddr)
+static u64
+tioca_dma_d48(struct pci_dev *pdev, u64 paddr)
 {
         struct tioca_common *tioca_common;
         struct tioca __iomem *ca_base;
-        uint64_t ct_addr;
+        u64 ct_addr;
         dma_addr_t bus_addr;
-        uint32_t node_upper;
-        uint64_t agp_dma_extn;
+        u32 node_upper;
+        u64 agp_dma_extn;
         struct pcidev_info *pcidev_info = SN_PCIDEV_INFO(pdev);
 
         tioca_common = (struct tioca_common *)pcidev_info->pdi_pcibus_info;
@@ -367,10 +367,10 @@ tioca_dma_d48(struct pci_dev *pdev, uint64_t paddr)
  * dma_addr_t is guarenteed to be contiguous in CA bus space.
  */
 static dma_addr_t
-tioca_dma_mapped(struct pci_dev *pdev, uint64_t paddr, size_t req_size)
+tioca_dma_mapped(struct pci_dev *pdev, u64 paddr, size_t req_size)
 {
         int i, ps, ps_shift, entry, entries, mapsize, last_entry;
-        uint64_t xio_addr, end_xio_addr;
+        u64 xio_addr, end_xio_addr;
         struct tioca_common *tioca_common;
         struct tioca_kernel *tioca_kern;
         dma_addr_t bus_addr = 0;
@@ -514,10 +514,10 @@ tioca_dma_unmap(struct pci_dev *pdev, dma_addr_t bus_addr, int dir)
  * The mapping mode used is based on the devices dma_mask.  As a last resort
  * use the GART mapped mode.
  */
-static uint64_t
-tioca_dma_map(struct pci_dev *pdev, uint64_t paddr, size_t byte_count)
+static u64
+tioca_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count)
 {
-        uint64_t mapaddr;
+        u64 mapaddr;
 
         /*
          * If card is 64 or 48 bit addresable, use a direct mapping.  32
@@ -554,8 +554,8 @@ tioca_error_intr_handler(int irq, void *arg, struct pt_regs *pt)
 {
         struct tioca_common *soft = arg;
         struct ia64_sal_retval ret_stuff;
-        uint64_t segment;
-        uint64_t busnum;
+        u64 segment;
+        u64 busnum;
         ret_stuff.status = 0;
         ret_stuff.v0 = 0;
 
@@ -620,7 +620,7 @@ tioca_bus_fixup(struct pcibus_bussoft *prom_bussoft, struct pci_controller *cont
         INIT_LIST_HEAD(&tioca_kern->ca_dmamaps);
         tioca_kern->ca_closest_node =
             nasid_to_cnodeid(tioca_common->ca_closest_nasid);
-        tioca_common->ca_kernel_private = (uint64_t) tioca_kern;
+        tioca_common->ca_kernel_private = (u64) tioca_kern;
 
         bus = pci_find_bus(tioca_common->ca_common.bs_persist_segment,
                 tioca_common->ca_common.bs_persist_busnum);
diff --git a/arch/ia64/sn/pci/tioce_provider.c b/arch/ia64/sn/pci/tioce_provider.c
index dda196c9e324..e52831ed93eb 100644
--- a/arch/ia64/sn/pci/tioce_provider.c
+++ b/arch/ia64/sn/pci/tioce_provider.c
@@ -81,10 +81,10 @@
  * 61    - 0 since this is not an MSI transaction
  * 60:54 - reserved, MBZ
  */
-static uint64_t
+static u64
 tioce_dma_d64(unsigned long ct_addr)
 {
-        uint64_t bus_addr;
+        u64 bus_addr;
 
         bus_addr = ct_addr | (1UL << 63);
 
@@ -141,9 +141,9 @@ pcidev_to_tioce(struct pci_dev *pdev, struct tioce **base,
  * length, and if enough resources exist, fill in the ATE's and construct a
  * tioce_dmamap struct to track the mapping.
  */
-static uint64_t
+static u64
 tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
-                uint64_t ct_addr, int len)
+                u64 ct_addr, int len)
 {
         int i;
         int j;
@@ -152,11 +152,11 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
         int entries;
         int nates;
         int pagesize;
-        uint64_t *ate_shadow;
-        uint64_t *ate_reg;
-        uint64_t addr;
+        u64 *ate_shadow;
+        u64 *ate_reg;
+        u64 addr;
         struct tioce *ce_mmr;
-        uint64_t bus_base;
+        u64 bus_base;
         struct tioce_dmamap *map;
 
         ce_mmr = (struct tioce *)ce_kern->ce_common->ce_pcibus.bs_base;
@@ -224,7 +224,7 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
 
         addr = ct_addr;
         for (j = 0; j < nates; j++) {
-                uint64_t ate;
+                u64 ate;
 
                 ate = ATE_MAKE(addr, pagesize);
                 ate_shadow[i + j] = ate;
@@ -252,15 +252,15 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
  *
  * Map @paddr into 32-bit bus space of the CE associated with @pcidev_info.
  */
-static uint64_t
-tioce_dma_d32(struct pci_dev *pdev, uint64_t ct_addr)
+static u64
+tioce_dma_d32(struct pci_dev *pdev, u64 ct_addr)
 {
         int dma_ok;
         int port;
         struct tioce *ce_mmr;
         struct tioce_kernel *ce_kern;
-        uint64_t ct_upper;
-        uint64_t ct_lower;
+        u64 ct_upper;
+        u64 ct_lower;
         dma_addr_t bus_addr;
 
         ct_upper = ct_addr & ~0x3fffffffUL;
@@ -269,7 +269,7 @@ tioce_dma_d32(struct pci_dev *pdev, uint64_t ct_addr)
         pcidev_to_tioce(pdev, &ce_mmr, &ce_kern, &port);
 
         if (ce_kern->ce_port[port].dirmap_refcnt == 0) {
-                uint64_t tmp;
+                u64 tmp;
 
                 ce_kern->ce_port[port].dirmap_shadow = ct_upper;
                 writeq(ct_upper, &ce_mmr->ce_ure_dir_map[port]);
@@ -295,10 +295,10 @@ tioce_dma_d32(struct pci_dev *pdev, uint64_t ct_addr)
  * Given a TIOCE bus address, set the appropriate bit to indicate barrier
  * attributes.
  */
-static uint64_t
-tioce_dma_barrier(uint64_t bus_addr, int on)
+static u64
+tioce_dma_barrier(u64 bus_addr, int on)
 {
-        uint64_t barrier_bit;
+        u64 barrier_bit;
 
         /* barrier not supported in M40/M40S mode */
         if (TIOCE_M40_ADDR(bus_addr) || TIOCE_M40S_ADDR(bus_addr))
@@ -351,7 +351,7 @@ tioce_dma_unmap(struct pci_dev *pdev, dma_addr_t bus_addr, int dir)
 
                 list_for_each_entry(map, &ce_kern->ce_dmamap_list,
                                     ce_dmamap_list) {
-                        uint64_t last;
+                        u64 last;
 
                         last = map->pci_start + map->nbytes - 1;
                         if (bus_addr >= map->pci_start && bus_addr <= last)
@@ -385,17 +385,17 @@ tioce_dma_unmap(struct pci_dev *pdev, dma_addr_t bus_addr, int dir)
  * This is the main wrapper for mapping host physical pages to CE PCI space.
  * The mapping mode used is based on the device's dma_mask.
  */
-static uint64_t
-tioce_do_dma_map(struct pci_dev *pdev, uint64_t paddr, size_t byte_count,
+static u64
+tioce_do_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count,
                  int barrier)
 {
         unsigned long flags;
-        uint64_t ct_addr;
-        uint64_t mapaddr = 0;
+        u64 ct_addr;
+        u64 mapaddr = 0;
         struct tioce_kernel *ce_kern;
         struct tioce_dmamap *map;
         int port;
-        uint64_t dma_mask;
+        u64 dma_mask;
 
         dma_mask = (barrier) ? pdev->dev.coherent_dma_mask : pdev->dma_mask;
 
@@ -425,7 +425,7 @@ tioce_do_dma_map(struct pci_dev *pdev, uint64_t paddr, size_t byte_count,
          * address bits than this device can support.
          */
         list_for_each_entry(map, &ce_kern->ce_dmamap_list, ce_dmamap_list) {
-                uint64_t last;
+                u64 last;
 
                 last = map->ct_start + map->nbytes - 1;
                 if (ct_addr >= map->ct_start &&
@@ -501,8 +501,8 @@ dma_map_done:
  * Simply call tioce_do_dma_map() to create a map with the barrier bit clear
  * in the address.
  */
-static uint64_t
-tioce_dma(struct pci_dev *pdev, uint64_t paddr, size_t byte_count)
+static u64
+tioce_dma(struct pci_dev *pdev, u64 paddr, size_t byte_count)
 {
         return tioce_do_dma_map(pdev, paddr, byte_count, 0);
 }
@@ -515,8 +515,8 @@ tioce_dma(struct pci_dev *pdev, uint64_t paddr, size_t byte_count)
  *
  * Simply call tioce_do_dma_map() to create a map with the barrier bit set
  * in the address.
- */ static uint64_t
-tioce_dma_consistent(struct pci_dev *pdev, uint64_t paddr, size_t byte_count)
+ */ static u64
+tioce_dma_consistent(struct pci_dev *pdev, u64 paddr, size_t byte_count)
 {
         return tioce_do_dma_map(pdev, paddr, byte_count, 1);
 }
@@ -551,7 +551,7 @@ tioce_error_intr_handler(int irq, void *arg, struct pt_regs *pt)
 tioce_kern_init(struct tioce_common *tioce_common)
 {
         int i;
-        uint32_t tmp;
+        u32 tmp;
         struct tioce *tioce_mmr;
         struct tioce_kernel *tioce_kern;
 
@@ -563,7 +563,7 @@ tioce_kern_init(struct tioce_common *tioce_common)
         tioce_kern->ce_common = tioce_common;
         spin_lock_init(&tioce_kern->ce_lock);
         INIT_LIST_HEAD(&tioce_kern->ce_dmamap_list);
-        tioce_common->ce_kernel_private = (uint64_t) tioce_kern;
+        tioce_common->ce_kernel_private = (u64) tioce_kern;
 
         /*
          * Determine the secondary bus number of the port2 logical PPB.
@@ -575,7 +575,7 @@ tioce_kern_init(struct tioce_common *tioce_common)
         raw_pci_ops->read(tioce_common->ce_pcibus.bs_persist_segment,
                           tioce_common->ce_pcibus.bs_persist_busnum,
                           PCI_DEVFN(2, 0), PCI_SECONDARY_BUS, 1, &tmp);
-        tioce_kern->ce_port1_secondary = (uint8_t) tmp;
+        tioce_kern->ce_port1_secondary = (u8) tmp;
 
         /*
          * Set PMU pagesize to the largest size available, and zero out
@@ -615,7 +615,7 @@ tioce_force_interrupt(struct sn_irq_info *sn_irq_info)
         struct pcidev_info *pcidev_info;
         struct tioce_common *ce_common;
         struct tioce *ce_mmr;
-        uint64_t force_int_val;
+        u64 force_int_val;
 
         if (!sn_irq_info->irq_bridge)
                 return;
@@ -687,7 +687,7 @@ tioce_target_interrupt(struct sn_irq_info *sn_irq_info)
         struct tioce_common *ce_common;
         struct tioce *ce_mmr;
         int bit;
-        uint64_t vector;
+        u64 vector;
 
         pcidev_info = (struct pcidev_info *)sn_irq_info->irq_pciioinfo;
         if (!pcidev_info)
@@ -699,7 +699,7 @@ tioce_target_interrupt(struct sn_irq_info *sn_irq_info)
         bit = sn_irq_info->irq_int_bit;
 
         __sn_setq_relaxed(&ce_mmr->ce_adm_int_mask, (1UL << bit));
-        vector = (uint64_t)sn_irq_info->irq_irq << INTR_VECTOR_SHFT;
+        vector = (u64)sn_irq_info->irq_irq << INTR_VECTOR_SHFT;
         vector |= sn_irq_info->irq_xtalkaddr;
         writeq(vector, &ce_mmr->ce_adm_int_dest[bit]);
         __sn_clrq_relaxed(&ce_mmr->ce_adm_int_mask, (1UL << bit));
diff --git a/arch/mips/kernel/reset.c b/arch/mips/kernel/reset.c
index ae2ba67b7ef6..5e37df3111ad 100644
--- a/arch/mips/kernel/reset.c
+++ b/arch/mips/kernel/reset.c
@@ -12,6 +12,9 @@
 #include <linux/reboot.h>
 #include <asm/reboot.h>
 
+void (*pm_power_off)(void);
+EXPORT_SYMBOL(pm_power_off);
+
 /*
  * Urgs ...  Too many MIPS machines to handle this in a generic way.
  * So handle all using function pointers to machine specific
@@ -33,6 +36,9 @@ void machine_halt(void)
 
 void machine_power_off(void)
 {
+        if (pm_power_off)
+                pm_power_off();
+
         _machine_power_off();
 }
 
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/Kconfig b/arch/sh/Kconfig
index 8cf6d437a630..01bc7d589afe 100644
--- a/arch/sh/Kconfig
+++ b/arch/sh/Kconfig
@@ -33,9 +33,11 @@ config GENERIC_CALIBRATE_DELAY
         bool
         default y
 
+config GENERIC_IOMAP
+        bool
+
 config ARCH_MAY_HAVE_PC_FDC
         bool
-        default y
 
 source "init/Kconfig"
 
@@ -53,24 +55,28 @@ config SH_SOLUTION_ENGINE
 
 config SH_7751_SOLUTION_ENGINE
         bool "SolutionEngine7751"
+        select CPU_SUBTYPE_SH7751
         help
           Select 7751 SolutionEngine if configuring for a Hitachi SH7751
           evaluation board.
 
 config SH_7300_SOLUTION_ENGINE
         bool "SolutionEngine7300"
+        select CPU_SUBTYPE_SH7300
         help
           Select 7300 SolutionEngine if configuring for a Hitachi SH7300(SH-Mobile V)
           evaluation board.
 
 config SH_73180_SOLUTION_ENGINE
        bool "SolutionEngine73180"
+       select CPU_SUBTYPE_SH73180
        help
          Select 73180 SolutionEngine if configuring for a Hitachi SH73180(SH-Mobile 3)
          evaluation board.
 
 config SH_7751_SYSTEMH
         bool "SystemH7751R"
+        select CPU_SUBTYPE_SH7751R
         help
           Select SystemH if you are configuring for a Renesas SystemH
           7751R evaluation board.
@@ -81,27 +87,13 @@ config SH_STB1_HARP
 config SH_STB1_OVERDRIVE
         bool "STB1_Overdrive"
 
-config SH_HP620
-        bool "HP620"
+config SH_HP6XX
+        bool "HP6XX"
         help
-          Select HP620 if configuring for a HP jornada HP620.
+          Select HP6XX if configuring for a HP jornada HP6xx.
           More information (hardware only) at
           <http://www.hp.com/jornada/>.
 
-config SH_HP680
-        bool "HP680"
-        help
-          Select HP680 if configuring for a HP Jornada HP680.
-          More information (hardware only) at
-          <http://www.hp.com/jornada/products/680/>.
-
-config SH_HP690
-        bool "HP690"
-        help
-          Select HP690 if configuring for a HP Jornada HP690.
-          More information (hardware only)
-          at <http://www.hp.com/jornada/products/680/>.
-
 config SH_CQREEK
         bool "CqREEK"
         help
@@ -123,11 +115,13 @@ config SH_EC3104
 
 config SH_SATURN
         bool "Saturn"
+        select CPU_SUBTYPE_SH7604
         help
           Select Saturn if configuring for a SEGA Saturn.
 
 config SH_DREAMCAST
         bool "Dreamcast"
+        select CPU_SUBTYPE_SH7091
         help
           Select Dreamcast if configuring for a SEGA Dreamcast.
           More information at
@@ -142,6 +136,7 @@ config SH_BIGSUR
 
 config SH_SH2000
         bool "SH2000"
+        select CPU_SUBTYPE_SH7709
         help
           SH-2000 is a single-board computer based around SH7709A chip
           intended for embedded applications.
@@ -153,20 +148,22 @@ config SH_ADX
         bool "ADX"
 
 config SH_MPC1211
-        bool "MPC1211"
+        bool "Interface MPC1211"
+        help
+          CTP/PCI-SH02 is a CPU module computer that is produced
+          by Interface Corporation.
+          More information at <http://www.interface.co.jp>
 
 config SH_SH03
-        bool "SH03"
+        bool "Interface CTP/PCI-SH03"
         help
-          CTP/PCI-SH03 is a CPU module computer that produced
+          CTP/PCI-SH03 is a CPU module computer that is produced
           by Interface Corporation.
-          It is compact and excellent in durability.
-          It will play an active part in your factory or laboratory
-          as a FA computer.
           More information at <http://www.interface.co.jp>
 
 config SH_SECUREEDGE5410
         bool "SecureEdge5410"
+        select CPU_SUBTYPE_SH7751R
         help
           Select SecureEdge5410 if configuring for a SnapGear SH board.
           This includes both the OEM SecureEdge products as well as the
@@ -174,25 +171,49 @@ config SH_SECUREEDGE5410
 
 config SH_HS7751RVOIP
         bool "HS7751RVOIP"
+        select CPU_SUBTYPE_SH7751R
         help
           Select HS7751RVOIP if configuring for a Renesas Technology
           Sales VoIP board.
 
 config SH_RTS7751R2D
         bool "RTS7751R2D"
+        select CPU_SUBTYPE_SH7751R
         help
           Select RTS7751R2D if configuring for a Renesas Technology
           Sales SH-Graphics board.
 
+config SH_R7780RP
+        bool "R7780RP-1"
+        select CPU_SUBTYPE_SH7780
+        help
+          Select R7780RP-1 if configuring for a Renesas Solutions
+          HIGHLANDER board.
+
 config SH_EDOSK7705
         bool "EDOSK7705"
+        select CPU_SUBTYPE_SH7705
 
 config SH_SH4202_MICRODEV
         bool "SH4-202 MicroDev"
+        select CPU_SUBTYPE_SH4_202
         help
           Select SH4-202 MicroDev if configuring for a SuperH MicroDev board
           with an SH4-202 CPU.
 
+config SH_LANDISK
+        bool "LANDISK"
+        select CPU_SUBTYPE_SH7751R
+        help
+          I-O DATA DEVICE, INC. "LANDISK Series" support.
+
+config SH_TITAN
+        bool "TITAN"
+        select CPU_SUBTYPE_SH7751R
+        help
+          Select Titan if you are configuring for a Nimble Microsystems
+          NetEngine NP51R.
+
 config SH_UNKNOWN
         bool "BareCPU"
         help
@@ -207,168 +228,27 @@ config SH_UNKNOWN
 
 endchoice
 
-choice
-        prompt "Processor family"
-        default CPU_SH4
-        help
-          This option determines the CPU family to compile for. Supported
-          targets are SH-2, SH-3, and SH-4. These options are independent of
-          CPU functionality. As such, SH-DSP users will still want to select
-          their respective processor family in addition to the DSP support
-          option.
-
-config CPU_SH2
-        bool "SH-2"
-        select SH_WRITETHROUGH
-
-config CPU_SH3
-        bool "SH-3"
-
-config CPU_SH4
-        bool "SH-4"
-
-endchoice
-
-choice
-        prompt "Processor subtype"
-
-config CPU_SUBTYPE_SH7604
-        bool "SH7604"
-        depends on CPU_SH2
-        help
-          Select SH7604 if you have SH7604
-
-config CPU_SUBTYPE_SH7300
-        bool "SH7300"
-        depends on CPU_SH3
-
-config CPU_SUBTYPE_SH7705
-        bool "SH7705"
-        depends on CPU_SH3
-
-config CPU_SUBTYPE_SH7707
-        bool "SH7707"
-        depends on CPU_SH3
-        help
-          Select SH7707 if you have a  60 Mhz SH-3 HD6417707 CPU.
-
-config CPU_SUBTYPE_SH7708
-        bool "SH7708"
-        depends on CPU_SH3
-        help
-          Select SH7708 if you have a  60 Mhz SH-3 HD6417708S or
-          if you have a 100 Mhz SH-3 HD6417708R CPU.
-
-config CPU_SUBTYPE_SH7709
-        bool "SH7709"
-        depends on CPU_SH3
-        help
-          Select SH7709 if you have a  80 Mhz SH-3 HD6417709 CPU.
-
-config CPU_SUBTYPE_SH7750
-        bool "SH7750"
-        depends on CPU_SH4
-        help
-          Select SH7750 if you have a 200 Mhz SH-4 HD6417750 CPU.
-
-config CPU_SUBTYPE_SH7751
-        bool "SH7751/SH7751R"
-        depends on CPU_SH4
-        help
-          Select SH7751 if you have a 166 Mhz SH-4 HD6417751 CPU,
-          or if you have a HD6417751R CPU.
-
-config CPU_SUBTYPE_SH7760
-        bool "SH7760"
-        depends on CPU_SH4
-
-config CPU_SUBTYPE_SH73180
-       bool "SH73180"
-       depends on CPU_SH4
-
-config CPU_SUBTYPE_ST40STB1
-       bool "ST40STB1 / ST40RA"
-       depends on CPU_SH4
-       help
-         Select ST40STB1 if you have a ST40RA CPU.
-         This was previously called the ST40STB1, hence the option name.
-
-config CPU_SUBTYPE_ST40GX1
-       bool "ST40GX1"
-       depends on CPU_SH4
-       help
-         Select ST40GX1 if you have a ST40GX1 CPU.
-
-config CPU_SUBTYPE_SH4_202
-        bool "SH4-202"
-        depends on CPU_SH4
-
-endchoice
-
-config SH7705_CACHE_32KB
-    bool "Enable 32KB cache size for SH7705"
-    depends on CPU_SUBTYPE_SH7705
-    default y
-
-config MMU
-        bool "Support for memory management hardware"
-        depends on !CPU_SH2
-        default y
-        help
-          Early SH processors (such as the SH7604) lack an MMU. In order to
-          boot on these systems, this option must not be set.
-
-          On other systems (such as the SH-3 and 4) where an MMU exists,
-          turning this off will boot the kernel on these machines with the
-          MMU implicitly switched off.
-
-choice
-        prompt "HugeTLB page size"
-        depends on HUGETLB_PAGE && CPU_SH4 && MMU
-        default HUGETLB_PAGE_SIZE_64K
-
-config HUGETLB_PAGE_SIZE_64K
-        bool "64K"
-
-config HUGETLB_PAGE_SIZE_1MB
-        bool "1MB"
-
-endchoice
-
-config CMDLINE_BOOL
-        bool "Default bootloader kernel arguments"
-
-config CMDLINE
-        string "Initial kernel command string"
-        depends on CMDLINE_BOOL
-        default "console=ttySC1,115200"
+source "arch/sh/mm/Kconfig"
 
-# Platform-specific memory start and size definitions
 config MEMORY_START
-        hex "Physical memory start address" if !MEMORY_SET || MEMORY_OVERRIDE
-        default "0x08000000" if !MEMORY_SET || MEMORY_OVERRIDE || !MEMORY_OVERRIDE && SH_ADX || SH_MPC1211 || SH_SH03 || SH_SECUREEDGE5410 || SH_SH4202_MICRODEV
-        default "0x0c000000" if !MEMORY_OVERRIDE && (SH_DREAMCAST || SH_HP600 || SH_BIGSUR || SH_SH2000 || SH_73180_SOLUTION_ENGINE || SH_7300_SOLUTION_ENGINE || SH_7751_SOLUTION_ENGINE || SH_SOLUTION_ENGINE || SH_HS7751RVOIP || SH_RTS7751R2D || SH_EDOSK7705)
+        hex "Physical memory start address"
+        default "0x08000000"
         ---help---
           Computers built with Hitachi SuperH processors always
           map the ROM starting at address zero.  But the processor
           does not specify the range that RAM takes.
 
           The physical memory (RAM) start address will be automatically
-          set to 08000000, unless you selected one of the following
-          processor types: SolutionEngine, Overdrive, HP620, HP680, HP690,
-          in which case the start address will be set to 0c000000.
+          set to 08000000. Other platforms, such as the Solution Engine
+          boards typically map RAM at 0C000000.
 
-          Tweak this only when porting to a new machine which is not already
-          known by the config system.  Changing it from the known correct
+          Tweak this only when porting to a new machine which does not
+          already have a defconfig. Changing it from the known correct
           value on any of the known systems will only lead to disaster.
 
 config MEMORY_SIZE
-        hex "Physical memory size" if !MEMORY_SET || MEMORY_OVERRIDE
-        default "0x00400000" if !MEMORY_SET || MEMORY_OVERRIDE || !MEMORY_OVERRIDE && SH_ADX || !MEMORY_OVERRIDE && (SH_HP600 || SH_BIGSUR || SH_SH2000)
-        default "0x01000000" if !MEMORY_OVERRIDE && SH_DREAMCAST || SH_SECUREEDGE5410 || SH_EDOSK7705
-        default "0x02000000" if !MEMORY_OVERRIDE && (SH_73180_SOLUTION_ENGINE || SH_SOLUTION_ENGINE)
-        default "0x04000000" if !MEMORY_OVERRIDE && (SH_7300_SOLUTION_ENGINE || SH_7751_SOLUTION_ENGINE || SH_HS7751RVOIP || SH_RTS7751R2D || SH_SH4202_MICRODEV)
-        default "0x08000000" if SH_MPC1211 || SH_SH03
+        hex "Physical memory size"
+        default "0x00400000"
         help
           This sets the default memory size assumed by your SH kernel. It can
           be overridden as normal by the 'mem=' argument on the kernel command
@@ -376,21 +256,6 @@ config MEMORY_SIZE
           as 0x00400000 which was the default value before this became
           configurable.
 
-config MEMORY_SET
-        bool
-        depends on !MEMORY_OVERRIDE && (SH_MPC1211 || SH_SH03 || SH_ADX || SH_DREAMCAST || SH_HP600 || SH_BIGSUR || SH_SH2000 || SH_7751_SOLUTION_ENGINE || SH_SOLUTION_ENGINE || SH_SECUREEDGE5410 || SH_HS7751RVOIP || SH_RTS7751R2D || SH_SH4202_MICRODEV || SH_EDOSK7705)
-        default y
-        help
-          This is an option about which you will never be asked a question.
-          Therefore, I conclude that you do not exist - go away.
-
-          There is a grue here.
-
-# If none of the above have set memory start/size, ask the user.
-config MEMORY_OVERRIDE
-        bool "Override default load address and memory size"
-
-# XXX: break these out into the board-specific configs below
 config CF_ENABLER
         bool "Compact Flash Enabler support"
         depends on SH_ADX || SH_SOLUTION_ENGINE || SH_UNKNOWN || SH_CAT68701 || SH_SH03
@@ -434,10 +299,21 @@ config CF_BASE_ADDR
         default "0xb8000000" if CF_AREA6
         default "0xb4000000" if CF_AREA5
 
+menu "Processor features"
+
+config CPU_LITTLE_ENDIAN
+        bool "Little Endian"
+        help
+          Some SuperH machines can be configured for either little or big
+          endian byte order. These modes require different kernels. Say Y if
+          your machine is little endian, N if it's a big endian machine.
+
 # The SH7750 RTC module is disabled in the Dreamcast
 config SH_RTC
         bool
-        depends on !SH_DREAMCAST && !SH_SATURN && !SH_7300_SOLUTION_ENGINE && !SH_73180_SOLUTION_ENGINE
+        depends on !SH_DREAMCAST && !SH_SATURN && !SH_7300_SOLUTION_ENGINE && \
+                   !SH_73180_SOLUTION_ENGINE && !SH_LANDISK && \
+                   !SH_R7780RP
         default y
         help
           Selecting this option will allow the Linux kernel to emulate
@@ -476,104 +352,131 @@ config SH_ADC
 
           If unsure, say N.
 
-config SH_HP600
+config SH_STORE_QUEUES
+        bool "Support for Store Queues"
+        depends on CPU_SH4
+        help
+          Selecting this option will enable an in-kernel API for manipulating
+          the store queues integrated in the SH-4 processors.
+
+config CPU_HAS_INTEVT
         bool
-        depends on SH_HP620 || SH_HP680 || SH_HP690
-        default y
 
-config CPU_SUBTYPE_ST40
-       bool
-       depends on CPU_SUBTYPE_ST40STB1 || CPU_SUBTYPE_ST40GX1
-       default y
+config CPU_HAS_PINT_IRQ
+        bool
 
-source "mm/Kconfig"
+config CPU_HAS_INTC2_IRQ
+        bool
 
-config ZERO_PAGE_OFFSET
-        hex "Zero page offset"
-        default "0x00001000" if !(SH_MPC1211 || SH_SH03)
-        default "0x00004000" if SH_MPC1211 || SH_SH03
+config CPU_HAS_SR_RB
+        bool "CPU has SR.RB"
+        depends on CPU_SH3 || CPU_SH4
+        default y
         help
-          This sets the default offset of zero page.
+          This will enable the use of SR.RB register bank usage. Processors
+          that are lacking this bit must have another method in place for
+          accomplishing what is taken care of by the banked registers.
 
-# XXX: needs to lose subtype for system type
-config ST40_LMI_MEMORY
-        bool "Memory on LMI"
-        depends on CPU_SUBTYPE_ST40STB1
+          See <file:Documentation/sh/register-banks.txt> for further
+          information on SR.RB and register banking in the kernel in general.
 
-config MEMORY_START
-        hex
-        depends on CPU_SUBTYPE_ST40STB1 && ST40_LMI_MEMORY
-        default "0x08000000"
+endmenu
 
-config MEMORY_SIZE
-        hex
-        depends on CPU_SUBTYPE_ST40STB1 && ST40_LMI_MEMORY
-        default "0x00400000"
+menu "Timer support"
 
-config MEMORY_SET
-        bool
-        depends on CPU_SUBTYPE_ST40STB1 && ST40_LMI_MEMORY
+config SH_TMU
+        bool "TMU timer support"
         default y
-
-config BOOT_LINK_OFFSET
-        hex "Link address offset for booting"
-        default "0x00800000"
         help
-          This option allows you to set the link address offset of the zImage.
-          This can be useful if you are on a board which has a small amount of
-          memory.
+          This enables the use of the TMU as the system timer.
 
-config CPU_LITTLE_ENDIAN
-        bool "Little Endian"
-        help
-          Some SuperH machines can be configured for either little or big
-          endian byte order. These modes require different kernels. Say Y if
-          your machine is little endian, N if it's a big endian machine.
+endmenu
 
-config PREEMPT
-        bool "Preemptible Kernel (EXPERIMENTAL)"
-        depends on EXPERIMENTAL
+source "arch/sh/boards/renesas/hs7751rvoip/Kconfig"
 
-config UBC_WAKEUP
-        bool "Wakeup UBC on startup"
+source "arch/sh/boards/renesas/rts7751r2d/Kconfig"
+
+config SH_PCLK_FREQ_BOOL
+        bool "Set default pclk frequency"
+        default y if !SH_RTC
+        default n
+
+config SH_PCLK_FREQ
+        int "Peripheral clock frequency (in Hz)"
+        depends on SH_PCLK_FREQ_BOOL
+        default "50000000" if CPU_SUBTYPE_SH7750 || CPU_SUBTYPE_SH7780
+        default "60000000" if CPU_SUBTYPE_SH7751
+        default "33333333" if CPU_SUBTYPE_SH7300 || CPU_SUBTYPE_SH7770 || CPU_SUBTYPE_SH7760
+        default "27000000" if CPU_SUBTYPE_SH73180
+        default "66000000" if CPU_SUBTYPE_SH4_202
         help
-          Selecting this option will wakeup the User Break Controller (UBC) on
-          startup. Although the UBC is left in an awake state when the processor
-          comes up, some boot loaders misbehave by putting the UBC to sleep in a
-          power saving state, which causes issues with things like ptrace().
+          This option is used to specify the peripheral clock frequency.
+          This is necessary for determining the reference clock value on
+          platforms lacking an RTC.
 
-          If unsure, say N.
+menu "CPU Frequency scaling"
+
+source "drivers/cpufreq/Kconfig"
 
-config SH_WRITETHROUGH
-        bool "Use write-through caching"
-        default y if CPU_SH2
+config SH_CPU_FREQ
+        tristate "SuperH CPU Frequency driver"
+        depends on CPU_FREQ
+        select CPU_FREQ_TABLE
         help
-          Selecting this option will configure the caches in write-through
-          mode, as opposed to the default write-back configuration.
+          This adds the cpufreq driver for SuperH. At present, only
+          the SH-4 is supported.
 
-          Since there's sill some aliasing issues on SH-4, this option will
-          unfortunately still require the majority of flushing functions to
-          be implemented to deal with aliasing.
+          For details, take a look at <file:Documentation/cpu-freq>.
 
           If unsure, say N.
 
-config SH_OCRAM
-        bool "Operand Cache RAM (OCRAM) support"
+endmenu
+
+source "arch/sh/drivers/dma/Kconfig"
+
+source "arch/sh/cchips/Kconfig"
+
+config HEARTBEAT
+        bool "Heartbeat LED"
+        depends on SH_MPC1211 || SH_SH03 || SH_CAT68701 || \
+                   SH_STB1_HARP || SH_STB1_OVERDRIVE || SH_BIGSUR || \
+                   SH_7751_SOLUTION_ENGINE || SH_7300_SOLUTION_ENGINE || \
+                   SH_73180_SOLUTION_ENGINE || SH_SOLUTION_ENGINE || \
+                   SH_RTS7751R2D || SH_SH4202_MICRODEV || SH_LANDISK
         help
-          Selecting this option will automatically tear down the number of
-          sets in the dcache by half, which in turn exposes a memory range.
+          Use the power-on LED on your machine as a load meter.  The exact
+          behavior is platform-dependent, but normally the flash frequency is
+          a hyperbolic function of the 5-minute load average.
 
-          The addresses for the OC RAM base will vary according to the
-          processor version. Consult vendor documentation for specifics.
+endmenu
 
-          If unsure, say N.
+config ISA_DMA_API
+        bool
+        depends on MPC1211
+        default y
 
-config SH_STORE_QUEUES
-        bool "Support for Store Queues"
-        depends on CPU_SH4
+menu "Kernel features"
+
+config KEXEC
+        bool "kexec system call (EXPERIMENTAL)"
+        depends on EXPERIMENTAL
         help
-          Selecting this option will enable an in-kernel API for manipulating
-          the store queues integrated in the SH-4 processors.
+          kexec is a system call that implements the ability to shutdown your
+          current kernel, and to start another kernel.  It is like a reboot
+          but it is indepedent of the system firmware.  And like a reboot
+          you can start any kernel with it, not just Linux.
+
+          The name comes from the similiarity to the exec system call.
+
+          It is an ongoing process to be certain the hardware in a machine
+          is properly shutdown, so do not be surprised if this code does not
+          initially work for you.  It may help to enable device hotplugging
+          support.  As of this writing the exact hardware interface is
+          strongly in flux, so no good recommendation can be made.
+
+config PREEMPT
+        bool "Preemptible Kernel (EXPERIMENTAL)"
+        depends on EXPERIMENTAL
 
 config SMP
         bool "Symmetric multi-processing support"
@@ -610,87 +513,58 @@ config NR_CPUS
           This is purely to save memory - each supported CPU adds
           approximately eight kilobytes to the kernel image.
 
-config HS7751RVOIP_CODEC
-        bool "Support VoIP Codec section"
-        depends on SH_HS7751RVOIP
-        help
-          Selecting this option will support CODEC section.
-
-config RTS7751R2D_REV11
-        bool "RTS7751R2D Rev. 1.1 board support"
-        depends on SH_RTS7751R2D
-        help
-          Selecting this option will support version rev. 1.1.
-
-config SH_PCLK_CALC
-        bool
-        default n if CPU_SUBTYPE_SH7300 || CPU_SUBTYPE_SH73180
+config CPU_HAS_SR_RB
+        bool "CPU has SR.RB"
+        depends on CPU_SH3 || CPU_SH4
         default y
         help
-          This option will cause the PCLK value to be probed at run-time. It
-          will display a notification if the probed value has greater than a
-          1% variance of the hardcoded CONFIG_SH_PCLK_FREQ.
+          This will enable the use of SR.RB register bank usage. Processors
+          that are lacking this bit must have another method in place for
+          accomplishing what is taken care of by the banked registers.
 
-config SH_PCLK_FREQ
-        int "Peripheral clock frequency (in Hz)"
-        default "50000000" if CPU_SUBTYPE_SH7750
-        default "60000000" if CPU_SUBTYPE_SH7751
-        default "33333333" if CPU_SUBTYPE_SH7300
-        default "27000000" if CPU_SUBTYPE_SH73180
-        default "66000000" if CPU_SUBTYPE_SH4_202
-        default "1193182"
-        help
-          This option is used to specify the peripheral clock frequency. This
-          option must be set for each processor in order for the kernel to
-          function reliably. If no sane default exists, we use a default from
-          the legacy i8254. Any discrepancies will be reported on boot time
-          with an auto-probed frequency which should be considered the proper
-          value for your hardware.
+          See <file:Documentation/sh/register-banks.txt> for further
+          information on SR.RB and register banking in the kernel in general.
 
-menu "CPU Frequency scaling"
+endmenu
 
-source "drivers/cpufreq/Kconfig"
+menu "Boot options"
 
-config SH_CPU_FREQ
-        tristate "SuperH CPU Frequency driver"
-        depends on CPU_FREQ
-        select CPU_FREQ_TABLE
+config ZERO_PAGE_OFFSET
+        hex "Zero page offset"
+        default "0x00004000" if SH_MPC1211 || SH_SH03
+        default "0x00001000"
         help
-          This adds the cpufreq driver for SuperH. At present, only
-          the SH-4 is supported.
-
-          For details, take a look at <file:Documentation/cpu-freq>.
-
-          If unsure, say N.
+          This sets the default offset of zero page.
 
-endmenu
+config BOOT_LINK_OFFSET
+        hex "Link address offset for booting"
+        default "0x00800000"
+        help
+          This option allows you to set the link address offset of the zImage.
+          This can be useful if you are on a board which has a small amount of
+          memory.
 
-source "arch/sh/drivers/dma/Kconfig"
+config UBC_WAKEUP
+        bool "Wakeup UBC on startup"
+        help
+          Selecting this option will wakeup the User Break Controller (UBC) on
+          startup. Although the UBC is left in an awake state when the processor
+          comes up, some boot loaders misbehave by putting the UBC to sleep in a
+          power saving state, which causes issues with things like ptrace().
 
-source "arch/sh/cchips/Kconfig"
+          If unsure, say N.
 
-config HEARTBEAT
-        bool "Heartbeat LED"
-        depends on SH_MPC1211 || SH_SH03 || SH_CAT68701 || SH_STB1_HARP || SH_STB1_OVERDRIVE || SH_BIGSUR || SH_7751_SOLUTION_ENGINE || SH_7300_SOLUTION_ENGINE || SH_73180_SOLUTION_ENGINE || SH_SOLUTION_ENGINE || SH_RTS7751R2D || SH_SH4202_MICRODEV
-        help
-          Use the power-on LED on your machine as a load meter.  The exact
-          behavior is platform-dependent, but normally the flash frequency is
-          a hyperbolic function of the 5-minute load average.
+config CMDLINE_BOOL
+        bool "Default bootloader kernel arguments"
 
-config RTC_9701JE
-        tristate "EPSON RTC-9701JE support"
-        depends on SH_RTS7751R2D
-        help
-          Selecting this option will support EPSON RTC-9701JE.
+config CMDLINE
+        string "Initial kernel command string"
+        depends on CMDLINE_BOOL
+        default "console=ttySC1,115200"
 
 endmenu
 
-config ISA_DMA_API
-        bool
-        depends on MPC1211
-        default y
-
-menu "Bus options (PCI, PCMCIA, EISA, MCA, ISA)"
+menu "Bus options"
 
 # Even on SuperH devices which don't have an ISA bus,
 # this variable helps the PCMCIA modules handle
@@ -701,7 +575,7 @@ menu "Bus options (PCI, PCMCIA, EISA, MCA, ISA)"
 # PCMCIA outright. -- PFM.
 config ISA
         bool
-        default y if PCMCIA || SMC91X
+        default y if PCMCIA
         help
           Find out whether you have ISA slots on your motherboard.  ISA is the
           name of a bus system, i.e. the way the CPU talks to the other stuff
@@ -735,10 +609,9 @@ config MCA
 config SBUS
         bool
 
-config MAPLE
-        tristate "Maple Bus support"
-        depends on SH_DREAMCAST
-        default y
+config SUPERHYWAY
+        tristate "SuperHyway Bus support"
+        depends on CPU_SUBTYPE_SH4_202
 
 source "arch/sh/drivers/pci/Kconfig"
 
diff --git a/arch/sh/Kconfig.debug b/arch/sh/Kconfig.debug
index 3fab181da364..8fb31ab2c02c 100644
--- a/arch/sh/Kconfig.debug
+++ b/arch/sh/Kconfig.debug
@@ -17,7 +17,7 @@ config SH_STANDARD_BIOS
 
 config EARLY_SCIF_CONSOLE
         bool "Use early SCIF console"
-        depends on CPU_SH4
+        depends on CPU_SH4 || CPU_SH2A && !SH_STANDARD_BIOS
 
 config EARLY_PRINTK
         bool "Early printk support"
diff --git a/arch/sh/Makefile b/arch/sh/Makefile
index 67192d6b00d8..08c9515c4806 100644
--- a/arch/sh/Makefile
+++ b/arch/sh/Makefile
@@ -17,10 +17,30 @@
 cflags-y                                := -mb
 cflags-$(CONFIG_CPU_LITTLE_ENDIAN)      := -ml
 
+isa-y                                   := any
+isa-$(CONFIG_CPU_SH2)                   := sh2
+isa-$(CONFIG_CPU_SH3)                   := sh3
+isa-$(CONFIG_CPU_SH4)                   := sh4
+isa-$(CONFIG_CPU_SH4A)                  := sh4a
+isa-$(CONFIG_CPU_SH2A)                  := sh2a
+
+isa-$(CONFIG_SH_DSP)                    := $(isa-y)-dsp
+
+ifndef CONFIG_MMU
+isa-y                   := $(isa-y)-nommu
+endif
+
+ifndef CONFIG_SH_FPU
+isa-y                   := $(isa-y)-nofpu
+endif
+
+cflags-y        += $(call as-option,-Wa$(comma)-isa=$(isa-y),)
+
 cflags-$(CONFIG_CPU_SH2)                += -m2
 cflags-$(CONFIG_CPU_SH3)                += -m3
 cflags-$(CONFIG_CPU_SH4)                += -m4 \
         $(call cc-option,-mno-implicit-fp,-m4-nofpu)
+cflags-$(CONFIG_CPU_SH4A)               += $(call cc-option,-m4a-nofpu,)
 
 cflags-$(CONFIG_SH_DSP)                 += -Wa,-dsp
 cflags-$(CONFIG_SH_KGDB)                += -g
@@ -67,9 +87,7 @@ machdir-$(CONFIG_SH_7300_SOLUTION_ENGINE)	:= se/7300
 machdir-$(CONFIG_SH_73180_SOLUTION_ENGINE)      := se/73180
 machdir-$(CONFIG_SH_STB1_HARP)                  := harp
 machdir-$(CONFIG_SH_STB1_OVERDRIVE)             := overdrive
-machdir-$(CONFIG_SH_HP620)                      := hp6xx/hp620
-machdir-$(CONFIG_SH_HP680)                      := hp6xx/hp680
-machdir-$(CONFIG_SH_HP690)                      := hp6xx/hp690
+machdir-$(CONFIG_SH_HP6XX)                      := hp6xx
 machdir-$(CONFIG_SH_CQREEK)                     := cqreek
 machdir-$(CONFIG_SH_DMIDA)                      := dmida
 machdir-$(CONFIG_SH_EC3104)                     := ec3104
@@ -119,31 +137,39 @@ boot := arch/sh/boot
 
 CPPFLAGS_vmlinux.lds := -traditional
 
+ifneq ($(KBUILD_SRC),)
+incdir-prefix   := $(srctree)/include/asm-sh/
+else
+incdir-prefix   :=
+endif
+
 #       Update machine arch and proc symlinks if something which affects
 #       them changed.  We use .arch and .mach to indicate when they were
 #       updated last, otherwise make uses the target directory mtime.
 
 include/asm-sh/.cpu: $(wildcard include/config/cpu/*.h) include/config/MARKER
         @echo '  SYMLINK include/asm-sh/cpu -> include/asm-sh/$(cpuincdir-y)'
-ifneq ($(KBUILD_SRC),)
-        $(Q)mkdir -p include/asm-sh
-        $(Q)ln -fsn $(srctree)/include/asm-sh/$(cpuincdir-y) include/asm-sh/cpu
-else
-        $(Q)ln -fsn $(cpuincdir-y) include/asm-sh/cpu
-endif
+        $(Q)if [ ! -d include/asm-sh ]; then mkdir -p include/asm-sh; fi
+        $(Q)ln -fsn $(incdir-prefix)$(cpuincdir-y) include/asm-sh/cpu
         @touch $@
 
+#       Most boards have their own mach directories.  For the ones that
+#       don't, just reference the parent directory so the semantics are
+#       kept roughly the same.
+
 include/asm-sh/.mach: $(wildcard include/config/sh/*.h) include/config/MARKER
-        @echo '  SYMLINK include/asm-sh/mach -> include/asm-sh/$(incdir-y)'
-ifneq ($(KBUILD_SRC),)
-        $(Q)mkdir -p include/asm-sh
-        $(Q)ln -fsn $(srctree)/include/asm-sh/$(incdir-y) include/asm-sh/mach
-else
-        $(Q)ln -fsn $(incdir-y) include/asm-sh/mach
-endif
+        @echo -n '  SYMLINK include/asm-sh/mach -> '
+        $(Q)if [ ! -d include/asm-sh ]; then mkdir -p include/asm-sh; fi
+        $(Q)if [ -d $(incdir-prefix)$(incdir-y) ]; then \
+                echo -e 'include/asm-sh/$(incdir-y)'; \
+                ln -fsn $(incdir-prefix)$(incdir-y) \
+                        include/asm-sh/mach; \
+        else \
+                echo -e 'include/asm-sh'; \
+                ln -fsn $(incdir-prefix) include/asm-sh/mach; \
+        fi
         @touch $@
 
-
 archprepare: maketools include/asm-sh/.cpu include/asm-sh/.mach
 
 .PHONY: maketools FORCE
diff --git a/arch/sh/boards/hp6xx/Makefile b/arch/sh/boards/hp6xx/Makefile
new file mode 100644
index 000000000000..927fe0aa5dfa
--- /dev/null
+++ b/arch/sh/boards/hp6xx/Makefile
@@ -0,0 +1,6 @@
+#
+# Makefile for the HP6xx specific parts of the kernel
+#
+
+obj-y    := mach.o setup.o
+
diff --git a/arch/sh/boards/hp6xx/hp620/Makefile b/arch/sh/boards/hp6xx/hp620/Makefile
deleted file mode 100644
index 20691dbce347..000000000000
--- a/arch/sh/boards/hp6xx/hp620/Makefile
+++ /dev/null
@@ -1,6 +0,0 @@
-#
-# Makefile for the HP620 specific parts of the kernel
-#
-
-obj-y    := mach.o setup.o
-
diff --git a/arch/sh/boards/hp6xx/hp620/mach.c b/arch/sh/boards/hp6xx/hp620/mach.c
deleted file mode 100644
index 0392d82b4a7b..000000000000
--- a/arch/sh/boards/hp6xx/hp620/mach.c
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * linux/arch/sh/boards/hp6xx/hp620/mach.c
- * 
- * Copyright (C) 2000 Stuart Menefy (stuart.menefy@st.com)
- * 
- * May be copied or modified under the terms of the GNU General Public
- * License.  See linux/COPYING for more information.
- *
- * Machine vector for the HP620
- */
-
-#include <linux/init.h>
-
-#include <asm/machvec.h>
-#include <asm/rtc.h>
-#include <asm/machvec_init.h>
-
-#include <asm/io.h>
-#include <asm/hd64461/hd64461.h>
-#include <asm/irq.h>
-
-/*
- * The Machine Vector
- */
-
-struct sh_machine_vector mv_hp620 __initmv = {
-        .mv_nr_irqs             = HD64461_IRQBASE+HD64461_IRQ_NUM,
-
-        .mv_inb                 = hd64461_inb,
-        .mv_inw                 = hd64461_inw,
-        .mv_inl                 = hd64461_inl,
-        .mv_outb                = hd64461_outb,
-        .mv_outw                = hd64461_outw,
-        .mv_outl                = hd64461_outl,
-
-        .mv_inb_p               = hd64461_inb_p,
-        .mv_inw_p               = hd64461_inw,
-        .mv_inl_p               = hd64461_inl,
-        .mv_outb_p              = hd64461_outb_p,
-        .mv_outw_p              = hd64461_outw,
-        .mv_outl_p              = hd64461_outl,
-
-        .mv_insb                = hd64461_insb,
-        .mv_insw                = hd64461_insw,
-        .mv_insl                = hd64461_insl,
-        .mv_outsb               = hd64461_outsb,
-        .mv_outsw               = hd64461_outsw,
-        .mv_outsl               = hd64461_outsl,
-
-        .mv_irq_demux           = hd64461_irq_demux,
-};
-ALIAS_MV(hp620)
diff --git a/arch/sh/boards/hp6xx/hp620/setup.c b/arch/sh/boards/hp6xx/hp620/setup.c
deleted file mode 100644
index 045fc5da7274..000000000000
--- a/arch/sh/boards/hp6xx/hp620/setup.c
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * linux/arch/sh/boards/hp6xx/hp620/setup.c
- *
- * Copyright (C) 2002 Andriy Skulysh, 2005 Kristoffer Ericson
- *
- * May be copied or modified under the terms of the GNU General Public
- * License. See Linux/COPYING for more information.
- *
- * Setup code for an HP620.
- * Due to similiarity with hp680/hp690 same inits are done (for now)
- */
-
-#include <linux/config.h>
-#include <linux/init.h>
-#include <asm/hd64461/hd64461.h>
-#include <asm/io.h>
-#include <asm/hp6xx/hp6xx.h>
-#include <asm/cpu/dac.h>
-
-const char *get_system_type(void)
-{
-        return "HP620";
-}
-
-int __init platform_setup(void)
-{
-        u16 v;
-
-        v  = inw(HD64461_STBCR);
-        v |= HD64461_STBCR_SURTST | HD64461_STBCR_SIRST  |
-             HD64461_STBCR_STM1ST | HD64461_STBCR_STM0ST |
-             HD64461_STBCR_SAFEST | HD64461_STBCR_SPC0ST |
-             HD64461_STBCR_SMIAST | HD64461_STBCR_SAFECKE_OST |
-             HD64461_STBCR_SAFECKE_IST;
-        outw(v, HD64461_STBCR);
-
-        v  = inw(HD64461_GPADR);
-        v |= HD64461_GPADR_SPEAKER | HD64461_GPADR_PCMCIA0;
-        outw(v, HD64461_GPADR);
-
-        sh_dac_disable(DAC_SPEAKER_VOLUME);
-
-        return 0;
-}
-
diff --git a/arch/sh/boards/hp6xx/hp680/Makefile b/arch/sh/boards/hp6xx/hp680/Makefile
deleted file mode 100644
index 0beef11d9b11..000000000000
--- a/arch/sh/boards/hp6xx/hp680/Makefile
+++ /dev/null
@@ -1,6 +0,0 @@
-#
-# Makefile for the HP680 specific parts of the kernel
-#
-
-obj-y    := mach.o setup.o
-
diff --git a/arch/sh/boards/hp6xx/hp690/Makefile b/arch/sh/boards/hp6xx/hp690/Makefile
deleted file mode 100644
index fbbe95e75f83..000000000000
--- a/arch/sh/boards/hp6xx/hp690/Makefile
+++ /dev/null
@@ -1,6 +0,0 @@
-#
-# Makefile for the HP690 specific parts of the kernel
-#
-
-obj-y    := mach.o
-
diff --git a/arch/sh/boards/hp6xx/hp690/mach.c b/arch/sh/boards/hp6xx/hp690/mach.c
deleted file mode 100644
index 2a4c68783cd6..000000000000
--- a/arch/sh/boards/hp6xx/hp690/mach.c
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * linux/arch/sh/boards/hp6xx/hp690/mach.c
- *
- * Copyright (C) 2000 Stuart Menefy (stuart.menefy@st.com)
- *
- * May be copied or modified under the terms of the GNU General Public
- * License.  See linux/COPYING for more information.
- *
- * Machine vector for the HP690
- */
-
-#include <linux/init.h>
-
-#include <asm/machvec.h>
-#include <asm/rtc.h>
-#include <asm/machvec_init.h>
-
-#include <asm/io.h>
-#include <asm/hd64461/hd64461.h>
-#include <asm/irq.h>
-
-struct sh_machine_vector mv_hp690 __initmv = {
-        .mv_nr_irqs             = HD64461_IRQBASE+HD64461_IRQ_NUM,
-
-        .mv_inb                 = hd64461_inb,
-        .mv_inw                 = hd64461_inw,
-        .mv_inl                 = hd64461_inl,
-        .mv_outb                = hd64461_outb,
-        .mv_outw                = hd64461_outw,
-        .mv_outl                = hd64461_outl,
-
-        .mv_inb_p               = hd64461_inb_p,
-        .mv_inw_p               = hd64461_inw,
-        .mv_inl_p               = hd64461_inl,
-        .mv_outb_p              = hd64461_outb_p,
-        .mv_outw_p              = hd64461_outw,
-        .mv_outl_p              = hd64461_outl,
-
-        .mv_insb                = hd64461_insb,
-        .mv_insw                = hd64461_insw,
-        .mv_insl                = hd64461_insl,
-        .mv_outsb               = hd64461_outsb,
-        .mv_outsw               = hd64461_outsw,
-        .mv_outsl               = hd64461_outsl,
-
-        .mv_irq_demux           = hd64461_irq_demux,
-};
-ALIAS_MV(hp690)
diff --git a/arch/sh/boards/hp6xx/hp680/mach.c b/arch/sh/boards/hp6xx/mach.c
index d73486136045..08dbba910f74 100644
--- a/arch/sh/boards/hp6xx/hp680/mach.c
+++ b/arch/sh/boards/hp6xx/mach.c
@@ -1,5 +1,5 @@
 /*
- * linux/arch/sh/boards/hp6xx/hp680/mach.c
+ * linux/arch/sh/boards/hp6xx/mach.c
  *
  * Copyright (C) 2000 Stuart Menefy (stuart.menefy@st.com)
  *
@@ -8,19 +8,12 @@
  *
  * Machine vector for the HP680
  */
-
-#include <linux/init.h>
-
 #include <asm/machvec.h>
-#include <asm/rtc.h>
-#include <asm/machvec_init.h>
-
+#include <asm/hd64461.h>
 #include <asm/io.h>
-#include <asm/hd64461/hd64461.h>
-#include <asm/hp6xx/io.h>
 #include <asm/irq.h>
 
-struct sh_machine_vector mv_hp680 __initmv = {
+struct sh_machine_vector mv_hp6xx __initmv = {
         .mv_nr_irqs = HD64461_IRQBASE + HD64461_IRQ_NUM,
 
         .mv_inb = hd64461_inb,
@@ -50,4 +43,4 @@ struct sh_machine_vector mv_hp680 __initmv = {
         .mv_irq_demux = hd64461_irq_demux,
 };
 
-ALIAS_MV(hp680)
+ALIAS_MV(hp6xx)
diff --git a/arch/sh/boards/hp6xx/hp680/setup.c b/arch/sh/boards/hp6xx/setup.c
index 4170190f2644..6d94a8e2e67a 100644
--- a/arch/sh/boards/hp6xx/hp680/setup.c
+++ b/arch/sh/boards/hp6xx/setup.c
@@ -11,18 +11,19 @@
 
 #include <linux/config.h>
 #include <linux/init.h>
-#include <asm/hd64461/hd64461.h>
 #include <asm/io.h>
+#include <asm/hd64461.h>
 #include <asm/hp6xx/hp6xx.h>
 #include <asm/cpu/dac.h>
 
 const char *get_system_type(void)
 {
-        return "HP680";
+        return "HP6xx";
 }
 
 int __init platform_setup(void)
 {
+        u8 v8;
         u16 v;
         v = inw(HD64461_STBCR);
         v |= HD64461_STBCR_SURTST | HD64461_STBCR_SIRST |
@@ -30,12 +31,25 @@ int __init platform_setup(void)
             HD64461_STBCR_SAFEST | HD64461_STBCR_SPC0ST |
             HD64461_STBCR_SMIAST | HD64461_STBCR_SAFECKE_OST |
             HD64461_STBCR_SAFECKE_IST;
+#ifndef CONFIG_HD64461_ENABLER
+        v |= HD64461_STBCR_SPC1ST;
+#endif
         outw(v, HD64461_STBCR);
         v = inw(HD64461_GPADR);
         v |= HD64461_GPADR_SPEAKER | HD64461_GPADR_PCMCIA0;
         outw(v, HD64461_GPADR);
 
+        outw(HD64461_PCCGCR_VCC0 | HD64461_PCCSCR_VCC1, HD64461_PCC0GCR);
+
+#ifndef CONFIG_HD64461_ENABLER
+        outw(HD64461_PCCGCR_VCC0 | HD64461_PCCSCR_VCC1, HD64461_PCC1GCR);
+#endif
+
+        sh_dac_output(0, DAC_SPEAKER_VOLUME);
         sh_dac_disable(DAC_SPEAKER_VOLUME);
+        v8 = ctrl_inb(DACR);
+        v8 &= ~DACR_DAE;
+        ctrl_outb(v8,DACR);
 
         return 0;
 }
diff --git a/arch/sh/boards/overdrive/Makefile b/arch/sh/boards/overdrive/Makefile
index 1762b59e9279..245f03baf762 100644
--- a/arch/sh/boards/overdrive/Makefile
+++ b/arch/sh/boards/overdrive/Makefile
@@ -2,7 +2,7 @@
 # Makefile for the STMicroelectronics Overdrive specific parts of the kernel
 #
 
-obj-y    := mach.o setup.o io.o irq.o led.o time.o
+obj-y    := mach.o setup.o io.o irq.o led.o
 
 obj-$(CONFIG_PCI) += fpga.o galileo.o pcidma.o
 
diff --git a/arch/sh/boards/overdrive/setup.c b/arch/sh/boards/overdrive/setup.c
index a36ce0284ed3..94f6165d33b8 100644
--- a/arch/sh/boards/overdrive/setup.c
+++ b/arch/sh/boards/overdrive/setup.c
@@ -17,8 +17,6 @@
 #include <asm/overdrive/overdrive.h>
 #include <asm/overdrive/fpga.h>
 
-extern void od_time_init(void);
-
 const char *get_system_type(void)
 {
         return "SH7750 Overdrive";
@@ -31,11 +29,9 @@ int __init platform_setup(void)
 {
 #ifdef CONFIG_PCI
         init_overdrive_fpga();
-        galileo_init(); 
+        galileo_init();
 #endif
 
-        board_time_init = od_time_init;
-
         /* Enable RS232 receive buffers */
         writel(0x1e, OVERDRIVE_CTRL);
 }
diff --git a/arch/sh/boards/overdrive/time.c b/arch/sh/boards/overdrive/time.c
deleted file mode 100644
index 68533690e097..000000000000
--- a/arch/sh/boards/overdrive/time.c
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * arch/sh/boards/overdrive/time.c
- *
- * Copyright (C) 2000 Stuart Menefy (stuart.menefy@st.com)
- * Copyright (C) 2002 Paul Mundt (lethal@chaoticdreams.org)
- *
- * May be copied or modified under the terms of the GNU General Public
- * License.  See linux/COPYING for more information.
- *
- * STMicroelectronics Overdrive Support.
- */
-
-void od_time_init(void)
-{
-        struct frqcr_data {
-                unsigned short frqcr;
-                struct {
-                        unsigned char multiplier;
-                        unsigned char divisor;
-                } factor[3];
-        };
-
-        static struct frqcr_data st40_frqcr_table[] = {         
-                { 0x000, {{1,1}, {1,1}, {1,2}}},
-                { 0x002, {{1,1}, {1,1}, {1,4}}},
-                { 0x004, {{1,1}, {1,1}, {1,8}}},
-                { 0x008, {{1,1}, {1,2}, {1,2}}},
-                { 0x00A, {{1,1}, {1,2}, {1,4}}},
-                { 0x00C, {{1,1}, {1,2}, {1,8}}},
-                { 0x011, {{1,1}, {2,3}, {1,6}}},
-                { 0x013, {{1,1}, {2,3}, {1,3}}},
-                { 0x01A, {{1,1}, {1,2}, {1,4}}},
-                { 0x01C, {{1,1}, {1,2}, {1,8}}},
-                { 0x023, {{1,1}, {2,3}, {1,3}}},
-                { 0x02C, {{1,1}, {1,2}, {1,8}}},
-                { 0x048, {{1,2}, {1,2}, {1,4}}},
-                { 0x04A, {{1,2}, {1,2}, {1,6}}},
-                { 0x04C, {{1,2}, {1,2}, {1,8}}},
-                { 0x05A, {{1,2}, {1,3}, {1,6}}},
-                { 0x05C, {{1,2}, {1,3}, {1,6}}},
-                { 0x063, {{1,2}, {1,4}, {1,4}}},
-                { 0x06C, {{1,2}, {1,4}, {1,8}}},
-                { 0x091, {{1,3}, {1,3}, {1,6}}},
-                { 0x093, {{1,3}, {1,3}, {1,6}}},
-                { 0x0A3, {{1,3}, {1,6}, {1,6}}},
-                { 0x0DA, {{1,4}, {1,4}, {1,8}}},
-                { 0x0DC, {{1,4}, {1,4}, {1,8}}},
-                { 0x0EC, {{1,4}, {1,8}, {1,8}}},
-                { 0x123, {{1,4}, {1,4}, {1,8}}},
-                { 0x16C, {{1,4}, {1,8}, {1,8}}},
-        };
-
-        struct memclk_data {
-                unsigned char multiplier;
-                unsigned char divisor;
-        };
-        static struct memclk_data st40_memclk_table[8] = {
-                {1,1},  // 000
-                {1,2},  // 001
-                {1,3},  // 010
-                {2,3},  // 011
-                {1,4},  // 100
-                {1,6},  // 101
-                {1,8},  // 110
-                {1,8}   // 111
-        };
-
-        unsigned long pvr;
-
-        /* 
-         * This should probably be moved into the SH3 probing code, and then
-         * use the processor structure to determine which CPU we are running
-         * on.
-         */
-        pvr = ctrl_inl(CCN_PVR);
-        printk("PVR %08x\n", pvr);
-
-        if (((pvr >> CCN_PVR_CHIP_SHIFT) & CCN_PVR_CHIP_MASK) == CCN_PVR_CHIP_ST40STB1) {
-                /* 
-                 * Unfortunatly the STB1 FRQCR values are different from the
-                 * 7750 ones.
-                 */
-                struct frqcr_data *d;
-                int a;
-                unsigned long memclkcr;
-                struct memclk_data *e;
-
-                for (a=0; a<ARRAY_SIZE(st40_frqcr_table); a++) {
-                        d = &st40_frqcr_table[a];
-                        if (d->frqcr == (frqcr & 0x1ff))
-                                break;
-                }
-                if (a == ARRAY_SIZE(st40_frqcr_table)) {
-                        d = st40_frqcr_table;
-                        printk("ERROR: Unrecognised FRQCR value, using default multipliers\n");
-                }
-
-                memclkcr = ctrl_inl(CLOCKGEN_MEMCLKCR);
-                e = &st40_memclk_table[memclkcr & MEMCLKCR_RATIO_MASK];
-
-                printk("Clock multipliers: CPU: %d/%d Bus: %d/%d Mem: %d/%d Periph: %d/%d\n",
-                       d->factor[0].multiplier, d->factor[0].divisor,
-                       d->factor[1].multiplier, d->factor[1].divisor,
-                       e->multiplier,           e->divisor,
-                       d->factor[2].multiplier, d->factor[2].divisor);
-                
-                current_cpu_data.master_clock = current_cpu_data.module_clock *
-                                                d->factor[2].divisor /
-                                                d->factor[2].multiplier;
-                current_cpu_data.bus_clock    = current_cpu_data.master_clock *
-                                                d->factor[1].multiplier /
-                                                d->factor[1].divisor;
-                current_cpu_data.memory_clock = current_cpu_data.master_clock *
-                                                e->multiplier / e->divisor;
-                current_cpu_data.cpu_clock    = current_cpu_data.master_clock *
-                                                d->factor[0].multiplier /
-                                                d->factor[0].divisor;
-}
-
diff --git a/arch/sh/configs/hp680_defconfig b/arch/sh/configs/hp6xx_defconfig
index c85d3655b53c..b36f102cec81 100644
--- a/arch/sh/configs/hp680_defconfig
+++ b/arch/sh/configs/hp6xx_defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.11-sh
-# Wed Mar  2 15:09:41 2005
+# Linux kernel version: 2.6.15-sh
+# Wed Jan  4 15:32:56 2006
 #
 CONFIG_SUPERH=y
 CONFIG_UID16=y
@@ -17,31 +17,36 @@ CONFIG_EXPERIMENTAL=y
 # CONFIG_CLEAN_COMPILE is not set
 CONFIG_BROKEN=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 is not set
 # CONFIG_BSD_PROCESS_ACCT is not set
 # CONFIG_SYSCTL is not set
-# CONFIG_AUDIT is not set
-CONFIG_LOG_BUF_SHIFT=14
-# CONFIG_HOTPLUG is not set
+CONFIG_HOTPLUG=y
 # CONFIG_IKCONFIG is not set
+CONFIG_INITRAMFS_SOURCE=""
+CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 # CONFIG_EMBEDDED is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+CONFIG_PRINTK=y
+CONFIG_BUG=y
+CONFIG_BASE_FULL=y
 CONFIG_FUTEX=y
 CONFIG_EPOLL=y
-# CONFIG_CC_OPTIMIZE_FOR_SIZE 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_TINY_SHMEM is not set
+CONFIG_BASE_SMALL=0
 
 #
 # Loadable module support
@@ -49,6 +54,24 @@ CONFIG_CC_ALIGN_JUMPS=0
 # CONFIG_MODULES 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"
+
+#
 # System type
 #
 # CONFIG_SH_SOLUTION_ENGINE is not set
@@ -58,9 +81,7 @@ CONFIG_CC_ALIGN_JUMPS=0
 # CONFIG_SH_7751_SYSTEMH is not set
 # CONFIG_SH_STB1_HARP is not set
 # CONFIG_SH_STB1_OVERDRIVE is not set
-# CONFIG_SH_HP620 is not set
-CONFIG_SH_HP680=y
-# CONFIG_SH_HP690 is not set
+CONFIG_SH_HP6XX=y
 # CONFIG_SH_CQREEK is not set
 # CONFIG_SH_DMIDA is not set
 # CONFIG_SH_EC3104 is not set
@@ -77,43 +98,90 @@ CONFIG_SH_HP680=y
 # CONFIG_SH_RTS7751R2D is not set
 # CONFIG_SH_EDOSK7705 is not set
 # CONFIG_SH_SH4202_MICRODEV is not set
+# CONFIG_SH_LANDISK is not set
+# CONFIG_SH_TITAN is not set
 # CONFIG_SH_UNKNOWN is not set
-# CONFIG_CPU_SH2 is not set
+
+#
+# Processor selection
+#
 CONFIG_CPU_SH3=y
-# CONFIG_CPU_SH4 is not set
+
+#
+# SH-2 Processor Support
+#
 # CONFIG_CPU_SUBTYPE_SH7604 is not set
+
+#
+# SH-3 Processor Support
+#
 # CONFIG_CPU_SUBTYPE_SH7300 is not set
 # CONFIG_CPU_SUBTYPE_SH7705 is not set
 # CONFIG_CPU_SUBTYPE_SH7707 is not set
 # CONFIG_CPU_SUBTYPE_SH7708 is not set
 CONFIG_CPU_SUBTYPE_SH7709=y
+
+#
+# SH-4 Processor Support
+#
 # CONFIG_CPU_SUBTYPE_SH7750 is not set
+# CONFIG_CPU_SUBTYPE_SH7091 is not set
+# CONFIG_CPU_SUBTYPE_SH7750R is not set
+# CONFIG_CPU_SUBTYPE_SH7750S is not set
 # CONFIG_CPU_SUBTYPE_SH7751 is not set
+# CONFIG_CPU_SUBTYPE_SH7751R is not set
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
-# CONFIG_CPU_SUBTYPE_SH73180 is not set
+# CONFIG_CPU_SUBTYPE_SH4_202 is not set
+
+#
+# ST40 Processor Support
+#
 # CONFIG_CPU_SUBTYPE_ST40STB1 is not set
 # CONFIG_CPU_SUBTYPE_ST40GX1 is not set
-# CONFIG_CPU_SUBTYPE_SH4_202 is not set
+
+#
+# SH-4A Processor Support
+#
+# CONFIG_CPU_SUBTYPE_SH73180 is not set
+# CONFIG_CPU_SUBTYPE_SH7770 is not set
+# CONFIG_CPU_SUBTYPE_SH7780 is not set
+
+#
+# Memory management options
+#
 CONFIG_MMU=y
-# CONFIG_CMDLINE_BOOL is not set
+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
+
+#
+# Cache configuration
+#
+# CONFIG_SH_DIRECT_MAPPED is not set
+# CONFIG_SH_WRITETHROUGH is not set
+# CONFIG_SH_OCRAM is not set
 CONFIG_MEMORY_START=0x0c000000
 CONFIG_MEMORY_SIZE=0x00400000
-CONFIG_MEMORY_SET=y
-# CONFIG_MEMORY_OVERRIDE is not set
+
+#
+# Processor features
+#
+CONFIG_CPU_LITTLE_ENDIAN=y
 CONFIG_SH_RTC=y
 # CONFIG_SH_DSP is not set
 CONFIG_SH_ADC=y
-CONFIG_SH_HP600=y
-CONFIG_ZERO_PAGE_OFFSET=0x00001000
-CONFIG_BOOT_LINK_OFFSET=0x00800000
-CONFIG_CPU_LITTLE_ENDIAN=y
-# CONFIG_PREEMPT is not set
-# CONFIG_UBC_WAKEUP is not set
-# CONFIG_SH_WRITETHROUGH is not set
-# CONFIG_SH_OCRAM is not set
-# CONFIG_SMP is not set
-CONFIG_SH_PCLK_CALC=y
-CONFIG_SH_PCLK_FREQ=1193182
+
+#
+# Timer support
+#
+CONFIG_SH_TMU=y
+CONFIG_SH_PCLK_FREQ_BOOL=y
+CONFIG_SH_PCLK_FREQ=22110000
 
 #
 # CPU Frequency scaling
@@ -123,7 +191,10 @@ CONFIG_SH_PCLK_FREQ=1193182
 #
 # DMA support
 #
-# CONFIG_SH_DMA is not set
+CONFIG_SH_DMA=y
+CONFIG_NR_ONCHIP_DMA_CHANNELS=4
+# CONFIG_NR_DMA_CHANNELS_BOOL is not set
+# CONFIG_DMA_PAGE_OPS is not set
 
 #
 # Companion Chips
@@ -132,21 +203,47 @@ CONFIG_HD6446X_SERIES=y
 CONFIG_HD64461=y
 # CONFIG_HD64465 is not set
 CONFIG_HD64461_IRQ=36
-# CONFIG_HD64461_ENABLER is not set
+CONFIG_HD64461_IOBASE=0xb0000000
+CONFIG_HD64461_ENABLER=y
+
+#
+# Kernel features
+#
+# CONFIG_KEXEC is not set
+# CONFIG_PREEMPT is not set
+# CONFIG_SMP is not set
 
 #
-# Bus options (PCI, PCMCIA, EISA, MCA, ISA)
+# Boot options
 #
+CONFIG_ZERO_PAGE_OFFSET=0x00001000
+CONFIG_BOOT_LINK_OFFSET=0x00800000
+# CONFIG_UBC_WAKEUP is not set
+# CONFIG_CMDLINE_BOOL is not set
+
+#
+# Bus options
+#
+CONFIG_ISA=y
 # CONFIG_PCI is not set
 
 #
 # PCCARD (PCMCIA/CardBus) support
 #
-# CONFIG_PCCARD is not set
+CONFIG_PCCARD=y
+# CONFIG_PCMCIA_DEBUG is not set
+CONFIG_PCMCIA=y
+CONFIG_PCMCIA_LOAD_CIS=y
+CONFIG_PCMCIA_IOCTL=y
 
 #
 # PC-card bridges
 #
+# CONFIG_I82365 is not set
+# CONFIG_TCIC is not set
+CONFIG_HD64461_PCMCIA=y
+CONFIG_HD64461_PCMCIA_SOCKETS=1
+CONFIG_PCMCIA_PROBE=y
 
 #
 # PCI Hotplug Support
@@ -160,9 +257,9 @@ CONFIG_BINFMT_ELF=y
 # CONFIG_BINFMT_MISC is not set
 
 #
-# SH initrd options
+# Networking
 #
-# CONFIG_EMBEDDED_RAMDISK is not set
+# CONFIG_NET is not set
 
 #
 # Device Drivers
@@ -173,7 +270,11 @@ CONFIG_BINFMT_ELF=y
 #
 # CONFIG_STANDALONE is not set
 CONFIG_PREVENT_FIRMWARE_BUILD=y
-# CONFIG_FW_LOADER is not set
+CONFIG_FW_LOADER=y
+
+#
+# Connector - unified userspace <-> kernelspace linker
+#
 
 #
 # Memory Technology Devices (MTD)
@@ -188,30 +289,20 @@ CONFIG_PREVENT_FIRMWARE_BUILD=y
 #
 # Plug and Play support
 #
+# CONFIG_PNP is not set
 
 #
 # Block devices
 #
-# CONFIG_BLK_DEV_FD is not set
 # CONFIG_BLK_DEV_COW_COMMON is not set
 # CONFIG_BLK_DEV_LOOP is not set
 CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_COUNT=16
 CONFIG_BLK_DEV_RAM_SIZE=4096
 CONFIG_BLK_DEV_INITRD=y
-CONFIG_INITRAMFS_SOURCE=""
-# CONFIG_LBD is not set
 # CONFIG_CDROM_PKTCDVD is not set
 
 #
-# IO Schedulers
-#
-CONFIG_IOSCHED_NOOP=y
-CONFIG_IOSCHED_AS=y
-CONFIG_IOSCHED_DEADLINE=y
-CONFIG_IOSCHED_CFQ=y
-
-#
 # ATA/ATAPI/MFM/RLL support
 #
 CONFIG_IDE=y
@@ -224,6 +315,7 @@ CONFIG_BLK_DEV_IDE=y
 # CONFIG_BLK_DEV_IDE_SATA is not set
 CONFIG_BLK_DEV_IDEDISK=y
 # CONFIG_IDEDISK_MULTI_MODE is not set
+# CONFIG_BLK_DEV_IDECS is not set
 # CONFIG_BLK_DEV_IDECD is not set
 # CONFIG_BLK_DEV_IDETAPE is not set
 # CONFIG_BLK_DEV_IDEFLOPPY is not set
@@ -235,6 +327,7 @@ CONFIG_BLK_DEV_IDEDISK=y
 CONFIG_IDE_GENERIC=y
 CONFIG_IDE_SH=y
 # CONFIG_IDE_ARM is not set
+# CONFIG_IDE_CHIPSETS is not set
 # CONFIG_BLK_DEV_IDEDMA is not set
 # CONFIG_IDEDMA_AUTO is not set
 # CONFIG_BLK_DEV_HD is not set
@@ -242,9 +335,15 @@ CONFIG_IDE_SH=y
 #
 # SCSI device support
 #
+# CONFIG_RAID_ATTRS is not set
 # CONFIG_SCSI is not set
 
 #
+# Old CD-ROM drivers (not SCSI, not IDE)
+#
+# CONFIG_CD_NO_IDESCSI is not set
+
+#
 # Multi-device support (RAID and LVM)
 #
 # CONFIG_MD is not set
@@ -252,6 +351,7 @@ CONFIG_IDE_SH=y
 #
 # Fusion MPT device support
 #
+# CONFIG_FUSION is not set
 
 #
 # IEEE 1394 (FireWire) support
@@ -263,9 +363,8 @@ CONFIG_IDE_SH=y
 #
 
 #
-# Networking support
+# Network device support
 #
-# CONFIG_NET is not set
 # CONFIG_NETPOLL is not set
 # CONFIG_NET_POLL_CONTROLLER is not set
 
@@ -296,17 +395,6 @@ CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
 # CONFIG_INPUT_EVBUG is not set
 
 #
-# Input I/O drivers
-#
-# CONFIG_GAMEPORT is not set
-CONFIG_SOUND_GAMEPORT=y
-CONFIG_SERIO=y
-# CONFIG_SERIO_I8042 is not set
-# CONFIG_SERIO_SERPORT is not set
-# CONFIG_SERIO_CT82C710 is not set
-# CONFIG_SERIO_RAW is not set
-
-#
 # Input Device Drivers
 #
 # CONFIG_INPUT_KEYBOARD is not set
@@ -316,6 +404,15 @@ CONFIG_SERIO=y
 # CONFIG_INPUT_MISC is not set
 
 #
+# Hardware I/O ports
+#
+CONFIG_SERIO=y
+# CONFIG_SERIO_I8042 is not set
+# CONFIG_SERIO_SERPORT is not set
+# CONFIG_SERIO_RAW is not set
+# CONFIG_GAMEPORT is not set
+
+#
 # Character devices
 #
 CONFIG_VT=y
@@ -353,10 +450,22 @@ CONFIG_LEGACY_PTY_COUNT=256
 #
 # Ftape, the floppy tape device driver
 #
-# CONFIG_DRM is not set
+
+#
+# PCMCIA character devices
+#
+# CONFIG_SYNCLINK_CS is not set
+# CONFIG_CARDMAN_4000 is not set
+# CONFIG_CARDMAN_4040 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 is not set
@@ -367,10 +476,21 @@ CONFIG_LEGACY_PTY_COUNT=256
 # CONFIG_W1 is not set
 
 #
+# Hardware Monitoring support
+#
+CONFIG_HWMON=y
+# CONFIG_HWMON_VID is not set
+# CONFIG_HWMON_DEBUG_CHIP is not set
+
+#
 # Misc devices
 #
 
 #
+# Multimedia Capabilities Port drivers
+#
+
+#
 # Multimedia devices
 #
 # CONFIG_VIDEO_DEV is not set
@@ -383,27 +503,35 @@ CONFIG_LEGACY_PTY_COUNT=256
 # Graphics support
 #
 CONFIG_FB=y
+CONFIG_FB_CFB_FILLRECT=y
+CONFIG_FB_CFB_COPYAREA=y
+CONFIG_FB_CFB_IMAGEBLIT=y
+# CONFIG_FB_MACMODES is not set
 # CONFIG_FB_MODE_HELPERS is not set
 # CONFIG_FB_TILEBLITTING is not set
 # CONFIG_FB_EPSON1355 is not set
+# CONFIG_FB_S1D13XXX is not set
 CONFIG_FB_HIT=y
 # CONFIG_FB_VIRTUAL is not set
 
 #
 # Console display driver support
 #
-# CONFIG_VGA_CONSOLE is not set
+# CONFIG_MDA_CONSOLE is not set
 CONFIG_DUMMY_CONSOLE=y
 CONFIG_FRAMEBUFFER_CONSOLE=y
+# CONFIG_FRAMEBUFFER_CONSOLE_ROTATION is not set
 CONFIG_FONTS=y
 # CONFIG_FONT_8x8 is not set
 # CONFIG_FONT_8x16 is not set
 # CONFIG_FONT_6x11 is not set
+# CONFIG_FONT_7x14 is not set
 CONFIG_FONT_PEARL_8x8=y
 # CONFIG_FONT_ACORN_8x8 is not set
 # CONFIG_FONT_MINI_4x6 is not set
 # CONFIG_FONT_SUN8x16 is not set
 # CONFIG_FONT_SUN12x22 is not set
+# CONFIG_FONT_10x18 is not set
 
 #
 # Logo configuration
@@ -414,7 +542,22 @@ CONFIG_FONT_PEARL_8x8=y
 #
 # Sound
 #
-# CONFIG_SOUND is not set
+CONFIG_SOUND=y
+
+#
+# Advanced Linux Sound Architecture
+#
+# CONFIG_SND is not set
+
+#
+# Open Sound System
+#
+CONFIG_SOUND_PRIME=y
+# CONFIG_OBSOLETE_OSS_DRIVER is not set
+# CONFIG_SOUND_MSNDCLAS is not set
+# CONFIG_SOUND_MSNDPIN is not set
+CONFIG_SOUND_SH_DAC_AUDIO=y
+CONFIG_SOUND_SH_DAC_AUDIO_CHANNEL=1
 
 #
 # USB support
@@ -423,7 +566,7 @@ CONFIG_FONT_PEARL_8x8=y
 # CONFIG_USB_ARCH_HAS_OHCI is not set
 
 #
-# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support' may also be needed; see USB_STORAGE Help for more information
+# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
 #
 
 #
@@ -442,25 +585,29 @@ CONFIG_FONT_PEARL_8x8=y
 # 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 is not set
 # CONFIG_JBD is not set
 # CONFIG_REISERFS_FS is not set
 # CONFIG_JFS_FS is not set
-
-#
-# XFS support
-#
+# CONFIG_FS_POSIX_ACL is not set
 # CONFIG_XFS_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
@@ -471,8 +618,11 @@ CONFIG_DNOTIFY=y
 #
 # DOS/FAT/NT Filesystems
 #
+CONFIG_FAT_FS=y
 # CONFIG_MSDOS_FS is not set
-# CONFIG_VFAT_FS is not set
+CONFIG_VFAT_FS=y
+CONFIG_FAT_DEFAULT_CODEPAGE=437
+CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
 # CONFIG_NTFS_FS is not set
 
 #
@@ -481,14 +631,11 @@ CONFIG_DNOTIFY=y
 CONFIG_PROC_FS=y
 CONFIG_PROC_KCORE=y
 CONFIG_SYSFS=y
-CONFIG_DEVFS_FS=y
-CONFIG_DEVFS_MOUNT=y
-# CONFIG_DEVFS_DEBUG is not set
-# CONFIG_DEVPTS_FS_XATTR is not set
 # CONFIG_TMPFS is not set
 # CONFIG_HUGETLBFS is not set
 # CONFIG_HUGETLB_PAGE is not set
 CONFIG_RAMFS=y
+# CONFIG_RELAYFS_FS is not set
 
 #
 # Miscellaneous filesystems
@@ -516,7 +663,46 @@ CONFIG_MSDOS_PARTITION=y
 #
 # Native Language Support
 #
-# CONFIG_NLS is not set
+CONFIG_NLS=y
+CONFIG_NLS_DEFAULT="iso8859-1"
+# CONFIG_NLS_CODEPAGE_437 is not set
+# CONFIG_NLS_CODEPAGE_737 is not set
+# CONFIG_NLS_CODEPAGE_775 is not set
+# CONFIG_NLS_CODEPAGE_850 is not set
+# CONFIG_NLS_CODEPAGE_852 is not set
+# CONFIG_NLS_CODEPAGE_855 is not set
+# CONFIG_NLS_CODEPAGE_857 is not set
+# CONFIG_NLS_CODEPAGE_860 is not set
+# CONFIG_NLS_CODEPAGE_861 is not set
+# CONFIG_NLS_CODEPAGE_862 is not set
+# CONFIG_NLS_CODEPAGE_863 is not set
+# CONFIG_NLS_CODEPAGE_864 is not set
+# CONFIG_NLS_CODEPAGE_865 is not set
+# CONFIG_NLS_CODEPAGE_866 is not set
+# CONFIG_NLS_CODEPAGE_869 is not set
+# CONFIG_NLS_CODEPAGE_936 is not set
+# CONFIG_NLS_CODEPAGE_950 is not set
+# CONFIG_NLS_CODEPAGE_932 is not set
+# CONFIG_NLS_CODEPAGE_949 is not set
+# CONFIG_NLS_CODEPAGE_874 is not set
+# CONFIG_NLS_ISO8859_8 is not set
+# CONFIG_NLS_CODEPAGE_1250 is not set
+# CONFIG_NLS_CODEPAGE_1251 is not set
+# CONFIG_NLS_ASCII is not set
+# CONFIG_NLS_ISO8859_1 is not set
+# CONFIG_NLS_ISO8859_2 is not set
+# CONFIG_NLS_ISO8859_3 is not set
+# CONFIG_NLS_ISO8859_4 is not set
+# CONFIG_NLS_ISO8859_5 is not set
+# CONFIG_NLS_ISO8859_6 is not set
+# CONFIG_NLS_ISO8859_7 is not set
+# CONFIG_NLS_ISO8859_9 is not set
+# CONFIG_NLS_ISO8859_13 is not set
+# CONFIG_NLS_ISO8859_14 is not set
+# CONFIG_NLS_ISO8859_15 is not set
+# CONFIG_NLS_KOI8_R is not set
+# CONFIG_NLS_KOI8_U is not set
+# CONFIG_NLS_UTF8 is not set
 
 #
 # Profiling support
@@ -526,7 +712,9 @@ CONFIG_MSDOS_PARTITION=y
 #
 # Kernel hacking
 #
+# CONFIG_PRINTK_TIME is not set
 # CONFIG_DEBUG_KERNEL is not set
+CONFIG_LOG_BUF_SHIFT=14
 # CONFIG_FRAME_POINTER is not set
 # CONFIG_SH_STANDARD_BIOS is not set
 # CONFIG_KGDB is not set
@@ -550,5 +738,6 @@ CONFIG_MSDOS_PARTITION=y
 # Library routines
 #
 # CONFIG_CRC_CCITT is not set
+# CONFIG_CRC16 is not set
 CONFIG_CRC32=y
 # CONFIG_LIBCRC32C is not set
diff --git a/arch/sh/drivers/dma/dma-api.c b/arch/sh/drivers/dma/dma-api.c
index 96e3036ec2bb..47c3e837599b 100644
--- a/arch/sh/drivers/dma/dma-api.c
+++ b/arch/sh/drivers/dma/dma-api.c
@@ -3,7 +3,7 @@
  *
  * SuperH-specific DMA management API
  *
- * Copyright (C) 2003, 2004  Paul Mundt
+ * Copyright (C) 2003, 2004, 2005  Paul Mundt
  *
  * 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
@@ -15,6 +15,7 @@
 #include <linux/spinlock.h>
 #include <linux/proc_fs.h>
 #include <linux/list.h>
+#include <linux/platform_device.h>
 #include <asm/dma.h>
 
 DEFINE_SPINLOCK(dma_spin_lock);
@@ -55,16 +56,14 @@ static LIST_HEAD(registered_dmac_list);
 
 struct dma_info *get_dma_info(unsigned int chan)
 {
-        struct list_head *pos, *tmp;
+        struct dma_info *info;
         unsigned int total = 0;
 
         /*
          * Look for each DMAC's range to determine who the owner of
          * the channel is.
          */
-        list_for_each_safe(pos, tmp, &registered_dmac_list) {
-                struct dma_info *info = list_entry(pos, struct dma_info, list);
-
+        list_for_each_entry(info, &registered_dmac_list, list) {
                 total += info->nr_channels;
                 if (chan > total)
                         continue;
@@ -75,6 +74,20 @@ struct dma_info *get_dma_info(unsigned int chan)
         return NULL;
 }
 
+static unsigned int get_nr_channels(void)
+{
+        struct dma_info *info;
+        unsigned int nr = 0;
+
+        if (unlikely(list_empty(&registered_dmac_list)))
+                return nr;
+
+        list_for_each_entry(info, &registered_dmac_list, list)
+                nr += info->nr_channels;
+
+        return nr;
+}
+
 struct dma_channel *get_dma_channel(unsigned int chan)
 {
         struct dma_info *info = get_dma_info(chan);
@@ -173,7 +186,7 @@ int dma_xfer(unsigned int chan, unsigned long from,
 static int dma_read_proc(char *buf, char **start, off_t off,
                          int len, int *eof, void *data)
 {
-        struct list_head *pos, *tmp;
+        struct dma_info *info;
         char *p = buf;
 
         if (list_empty(&registered_dmac_list))
@@ -182,8 +195,7 @@ static int dma_read_proc(char *buf, char **start, off_t off,
         /*
          * Iterate over each registered DMAC
          */
-        list_for_each_safe(pos, tmp, &registered_dmac_list) {
-                struct dma_info *info = list_entry(pos, struct dma_info, list);
+        list_for_each_entry(info, &registered_dmac_list, list) {
                 int i;
 
                 /*
@@ -205,9 +217,9 @@ static int dma_read_proc(char *buf, char **start, off_t off,
 #endif
 
 
-int __init register_dmac(struct dma_info *info)
+int register_dmac(struct dma_info *info)
 {
-        int i;
+        unsigned int total_channels, i;
 
         INIT_LIST_HEAD(&info->list);
 
@@ -217,6 +229,11 @@ int __init register_dmac(struct dma_info *info)
 
         BUG_ON((info->flags & DMAC_CHANNELS_CONFIGURED) && !info->channels);
 
+        info->pdev = platform_device_register_simple((char *)info->name, -1,
+                                                     NULL, 0);
+        if (IS_ERR(info->pdev))
+                return PTR_ERR(info->pdev);
+
         /*
          * Don't touch pre-configured channels
          */
@@ -232,10 +249,12 @@ int __init register_dmac(struct dma_info *info)
                 memset(info->channels, 0, size);
         }
 
+        total_channels = get_nr_channels();
         for (i = 0; i < info->nr_channels; i++) {
                 struct dma_channel *chan = info->channels + i;
 
                 chan->chan = i;
+                chan->vchan = i + total_channels;
 
                 memcpy(chan->dev_id, "Unused", 7);
 
@@ -245,9 +264,7 @@ int __init register_dmac(struct dma_info *info)
                 init_MUTEX(&chan->sem);
                 init_waitqueue_head(&chan->wait_queue);
 
-#ifdef CONFIG_SYSFS
-                dma_create_sysfs_files(chan);
-#endif
+                dma_create_sysfs_files(chan, info);
         }
 
         list_add(&info->list, &registered_dmac_list);
@@ -255,12 +272,18 @@ int __init register_dmac(struct dma_info *info)
         return 0;
 }
 
-void __exit unregister_dmac(struct dma_info *info)
+void unregister_dmac(struct dma_info *info)
 {
+        unsigned int i;
+
+        for (i = 0; i < info->nr_channels; i++)
+                dma_remove_sysfs_files(info->channels + i, info);
+
         if (!(info->flags & DMAC_CHANNELS_CONFIGURED))
                 kfree(info->channels);
 
         list_del(&info->list);
+        platform_device_unregister(info->pdev);
 }
 
 static int __init dma_api_init(void)
diff --git a/arch/sh/drivers/dma/dma-g2.c b/arch/sh/drivers/dma/dma-g2.c
index 231e3f6fb28f..5afab6f56ec3 100644
--- a/arch/sh/drivers/dma/dma-g2.c
+++ b/arch/sh/drivers/dma/dma-g2.c
@@ -140,7 +140,7 @@ static struct dma_ops g2_dma_ops = {
 };
 
 static struct dma_info g2_dma_info = {
-        .name           = "G2 DMA",
+        .name           = "g2_dmac",
         .nr_channels    = 4,
         .ops            = &g2_dma_ops,
         .flags          = DMAC_CHANNELS_TEI_CAPABLE,
@@ -160,6 +160,7 @@ static int __init g2_dma_init(void)
 static void __exit g2_dma_exit(void)
 {
         free_irq(HW_EVENT_G2_DMA, 0);
+        unregister_dmac(&g2_dma_info);
 }
 
 subsys_initcall(g2_dma_init);
diff --git a/arch/sh/drivers/dma/dma-isa.c b/arch/sh/drivers/dma/dma-isa.c
index 1c9bc45b8bcb..05a74ffdb68d 100644
--- a/arch/sh/drivers/dma/dma-isa.c
+++ b/arch/sh/drivers/dma/dma-isa.c
@@ -25,14 +25,14 @@
  * such, this code is meant for only the simplest of tasks (and shouldn't be
  * used in any new drivers at all).
  *
- * It should also be noted that various functions here are labelled as
- * being deprecated. This is due to the fact that the ops->xfer() method is
- * the preferred way of doing things (as well as just grabbing the spinlock
- * directly). As such, any users of this interface will be warned rather
- * loudly.
+ * NOTE: ops->xfer() is the preferred way of doing things. However, there
+ * are some users of the ISA DMA API that exist in common code that we
+ * don't necessarily want to go out of our way to break, so we still
+ * allow for some compatability at that level. Any new code is strongly
+ * advised to run far away from the ISA DMA API and use the SH DMA API
+ * directly.
  */
-
-unsigned long __deprecated claim_dma_lock(void)
+unsigned long claim_dma_lock(void)
 {
         unsigned long flags;
 
@@ -42,19 +42,19 @@ unsigned long __deprecated claim_dma_lock(void)
 }
 EXPORT_SYMBOL(claim_dma_lock);
 
-void __deprecated release_dma_lock(unsigned long flags)
+void release_dma_lock(unsigned long flags)
 {
         spin_unlock_irqrestore(&dma_spin_lock, flags);
 }
 EXPORT_SYMBOL(release_dma_lock);
 
-void __deprecated disable_dma(unsigned int chan)
+void disable_dma(unsigned int chan)
 {
         /* Nothing */
 }
 EXPORT_SYMBOL(disable_dma);
 
-void __deprecated enable_dma(unsigned int chan)
+void enable_dma(unsigned int chan)
 {
         struct dma_info *info = get_dma_info(chan);
         struct dma_channel *channel = &info->channels[chan];
diff --git a/arch/sh/drivers/dma/dma-pvr2.c b/arch/sh/drivers/dma/dma-pvr2.c
index 2e1d58f2d1b9..df604975ccc8 100644
--- a/arch/sh/drivers/dma/dma-pvr2.c
+++ b/arch/sh/drivers/dma/dma-pvr2.c
@@ -80,7 +80,7 @@ static struct dma_ops pvr2_dma_ops = {
 };
 
 static struct dma_info pvr2_dma_info = {
-        .name           = "PowerVR 2 DMA",
+        .name           = "pvr2_dmac",
         .nr_channels    = 1,
         .ops            = &pvr2_dma_ops,
         .flags          = DMAC_CHANNELS_TEI_CAPABLE,
@@ -98,6 +98,7 @@ static void __exit pvr2_dma_exit(void)
 {
         free_dma(PVR2_CASCADE_CHAN);
         free_irq(HW_EVENT_PVR2_DMA, 0);
+        unregister_dmac(&pvr2_dma_info);
 }
 
 subsys_initcall(pvr2_dma_init);
diff --git a/arch/sh/drivers/dma/dma-sh.c b/arch/sh/drivers/dma/dma-sh.c
index 31dacd4444b2..cca26c4c9d1b 100644
--- a/arch/sh/drivers/dma/dma-sh.c
+++ b/arch/sh/drivers/dma/dma-sh.c
@@ -5,6 +5,7 @@
  *
  * Copyright (C) 2000 Takashi YOSHII
  * Copyright (C) 2003, 2004 Paul Mundt
+ * Copyright (C) 2005 Andriy Skulysh
  *
  * 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
@@ -16,51 +17,28 @@
 #include <linux/irq.h>
 #include <linux/interrupt.h>
 #include <linux/module.h>
+#include <asm/dreamcast/dma.h>
 #include <asm/signal.h>
 #include <asm/irq.h>
 #include <asm/dma.h>
 #include <asm/io.h>
 #include "dma-sh.h"
 
-/*
- * The SuperH DMAC supports a number of transmit sizes, we list them here,
- * with their respective values as they appear in the CHCR registers.
- *
- * Defaults to a 64-bit transfer size.
- */
-enum {
-        XMIT_SZ_64BIT,
-        XMIT_SZ_8BIT,
-        XMIT_SZ_16BIT,
-        XMIT_SZ_32BIT,
-        XMIT_SZ_256BIT,
-};
-
-/*
- * The DMA count is defined as the number of bytes to transfer.
- */
-static unsigned int ts_shift[] = {
-        [XMIT_SZ_64BIT]         = 3,
-        [XMIT_SZ_8BIT]          = 0,
-        [XMIT_SZ_16BIT]         = 1,
-        [XMIT_SZ_32BIT]         = 2,
-        [XMIT_SZ_256BIT]        = 5,
-};
-
 static inline unsigned int get_dmte_irq(unsigned int chan)
 {
-        unsigned int irq;
+        unsigned int irq = 0;
 
         /*
          * Normally we could just do DMTE0_IRQ + chan outright, though in the
          * case of the 7751R, the DMTE IRQs for channels > 4 start right above
          * the SCIF
          */
-
         if (chan < 4) {
                 irq = DMTE0_IRQ + chan;
         } else {
+#ifdef DMTE4_IRQ
                 irq = DMTE4_IRQ + chan - 4;
+#endif
         }
 
         return irq;
@@ -78,9 +56,7 @@ static inline unsigned int calc_xmit_shift(struct dma_channel *chan)
 {
         u32 chcr = ctrl_inl(CHCR[chan->chan]);
 
-        chcr >>= 4;
-
-        return ts_shift[chcr & 0x0007];
+        return ts_shift[(chcr & CHCR_TS_MASK)>>CHCR_TS_SHIFT];
 }
 
 /*
@@ -109,8 +85,13 @@ static irqreturn_t dma_tei(int irq, void *dev_id, struct pt_regs *regs)
 
 static int sh_dmac_request_dma(struct dma_channel *chan)
 {
+        char name[32];
+
+        snprintf(name, sizeof(name), "DMAC Transfer End (Channel %d)",
+                 chan->chan);
+
         return request_irq(get_dmte_irq(chan->chan), dma_tei,
-                           SA_INTERRUPT, "DMAC Transfer End", chan);
+                           SA_INTERRUPT, name, chan);
 }
 
 static void sh_dmac_free_dma(struct dma_channel *chan)
@@ -118,10 +99,18 @@ static void sh_dmac_free_dma(struct dma_channel *chan)
         free_irq(get_dmte_irq(chan->chan), chan);
 }
 
-static void sh_dmac_configure_channel(struct dma_channel *chan, unsigned long chcr)
+static void
+sh_dmac_configure_channel(struct dma_channel *chan, unsigned long chcr)
 {
         if (!chcr)
-                chcr = RS_DUAL;
+                chcr = RS_DUAL | CHCR_IE;
+
+        if (chcr & CHCR_IE) {
+                chcr &= ~CHCR_IE;
+                chan->flags |= DMA_TEI_CAPABLE;
+        } else {
+                chan->flags &= ~DMA_TEI_CAPABLE;
+        }
 
         ctrl_outl(chcr, CHCR[chan->chan]);
 
@@ -130,22 +119,32 @@ static void sh_dmac_configure_channel(struct dma_channel *chan, unsigned long ch
 
 static void sh_dmac_enable_dma(struct dma_channel *chan)
 {
-        int irq = get_dmte_irq(chan->chan);
+        int irq;
         u32 chcr;
 
         chcr = ctrl_inl(CHCR[chan->chan]);
-        chcr |= CHCR_DE | CHCR_IE;
+        chcr |= CHCR_DE;
+
+        if (chan->flags & DMA_TEI_CAPABLE)
+                chcr |= CHCR_IE;
+
         ctrl_outl(chcr, CHCR[chan->chan]);
 
-        enable_irq(irq);
+        if (chan->flags & DMA_TEI_CAPABLE) {
+                irq = get_dmte_irq(chan->chan);
+                enable_irq(irq);
+        }
 }
 
 static void sh_dmac_disable_dma(struct dma_channel *chan)
 {
-        int irq = get_dmte_irq(chan->chan);
+        int irq;
         u32 chcr;
 
-        disable_irq(irq);
+        if (chan->flags & DMA_TEI_CAPABLE) {
+                irq = get_dmte_irq(chan->chan);
+                disable_irq(irq);
+        }
 
         chcr = ctrl_inl(CHCR[chan->chan]);
         chcr &= ~(CHCR_DE | CHCR_TE | CHCR_IE);
@@ -158,7 +157,7 @@ static int sh_dmac_xfer_dma(struct dma_channel *chan)
          * If we haven't pre-configured the channel with special flags, use
          * the defaults.
          */
-        if (!(chan->flags & DMA_CONFIGURED))
+        if (unlikely(!(chan->flags & DMA_CONFIGURED)))
                 sh_dmac_configure_channel(chan, 0);
 
         sh_dmac_disable_dma(chan);
@@ -178,9 +177,11 @@ static int sh_dmac_xfer_dma(struct dma_channel *chan)
          * cascading to the PVR2 DMAC. In this case, we still need to write
          * SAR and DAR, regardless of value, in order for cascading to work.
          */
-        if (chan->sar || (mach_is_dreamcast() && chan->chan == 2))
+        if (chan->sar || (mach_is_dreamcast() &&
+                          chan->chan == PVR2_CASCADE_CHAN))
                 ctrl_outl(chan->sar, SAR[chan->chan]);
-        if (chan->dar || (mach_is_dreamcast() && chan->chan == 2))
+        if (chan->dar || (mach_is_dreamcast() &&
+                          chan->chan == PVR2_CASCADE_CHAN))
                 ctrl_outl(chan->dar, DAR[chan->chan]);
 
         ctrl_outl(chan->count >> calc_xmit_shift(chan), DMATCR[chan->chan]);
@@ -198,17 +199,38 @@ static int sh_dmac_get_dma_residue(struct dma_channel *chan)
         return ctrl_inl(DMATCR[chan->chan]) << calc_xmit_shift(chan);
 }
 
-#if defined(CONFIG_CPU_SH4)
-static irqreturn_t dma_err(int irq, void *dev_id, struct pt_regs *regs)
+#ifdef CONFIG_CPU_SUBTYPE_SH7780
+#define dmaor_read_reg()        ctrl_inw(DMAOR)
+#define dmaor_write_reg(data)   ctrl_outw(data, DMAOR)
+#else
+#define dmaor_read_reg()        ctrl_inl(DMAOR)
+#define dmaor_write_reg(data)   ctrl_outl(data, DMAOR)
+#endif
+
+static inline int dmaor_reset(void)
 {
-        unsigned long dmaor = ctrl_inl(DMAOR);
+        unsigned long dmaor = dmaor_read_reg();
+
+        /* Try to clear the error flags first, incase they are set */
+        dmaor &= ~(DMAOR_NMIF | DMAOR_AE);
+        dmaor_write_reg(dmaor);
 
-        printk("DMAE: DMAOR=%lx\n", dmaor);
+        dmaor |= DMAOR_INIT;
+        dmaor_write_reg(dmaor);
 
-        ctrl_outl(ctrl_inl(DMAOR)&~DMAOR_NMIF, DMAOR);
-        ctrl_outl(ctrl_inl(DMAOR)&~DMAOR_AE, DMAOR);
-        ctrl_outl(ctrl_inl(DMAOR)|DMAOR_DME, DMAOR);
+        /* See if we got an error again */
+        if ((dmaor_read_reg() & (DMAOR_AE | DMAOR_NMIF))) {
+                printk(KERN_ERR "dma-sh: Can't initialize DMAOR.\n");
+                return -EINVAL;
+        }
 
+        return 0;
+}
+
+#if defined(CONFIG_CPU_SH4)
+static irqreturn_t dma_err(int irq, void *dev_id, struct pt_regs *regs)
+{
+        dmaor_reset();
         disable_irq(irq);
 
         return IRQ_HANDLED;
@@ -224,8 +246,8 @@ static struct dma_ops sh_dmac_ops = {
 };
 
 static struct dma_info sh_dmac_info = {
-        .name           = "SuperH DMAC",
-        .nr_channels    = 4,
+        .name           = "sh_dmac",
+        .nr_channels    = CONFIG_NR_ONCHIP_DMA_CHANNELS,
         .ops            = &sh_dmac_ops,
         .flags          = DMAC_CHANNELS_TEI_CAPABLE,
 };
@@ -248,7 +270,13 @@ static int __init sh_dmac_init(void)
                 make_ipr_irq(irq, DMA_IPR_ADDR, DMA_IPR_POS, DMA_PRIORITY);
         }
 
-        ctrl_outl(0x8000 | DMAOR_DME, DMAOR);
+        /*
+         * Initialize DMAOR, and clean up any error flags that may have
+         * been set.
+         */
+        i = dmaor_reset();
+        if (i < 0)
+                return i;
 
         return register_dmac(info);
 }
@@ -258,10 +286,12 @@ static void __exit sh_dmac_exit(void)
 #ifdef CONFIG_CPU_SH4
         free_irq(DMAE_IRQ, 0);
 #endif
+        unregister_dmac(&sh_dmac_info);
 }
 
 subsys_initcall(sh_dmac_init);
 module_exit(sh_dmac_exit);
 
+MODULE_AUTHOR("Takashi YOSHII, Paul Mundt, Andriy Skulysh");
+MODULE_DESCRIPTION("SuperH On-Chip DMAC Support");
 MODULE_LICENSE("GPL");
-
diff --git a/arch/sh/drivers/dma/dma-sh.h b/arch/sh/drivers/dma/dma-sh.h
index dd9d547539a2..0f591fbc922d 100644
--- a/arch/sh/drivers/dma/dma-sh.h
+++ b/arch/sh/drivers/dma/dma-sh.h
@@ -11,6 +11,8 @@
 #ifndef __DMA_SH_H
 #define __DMA_SH_H
 
+#include <asm/cpu/dma.h>
+
 /* Definitions for the SuperH DMAC */
 #define REQ_L   0x00000000
 #define REQ_E   0x00080000
@@ -26,27 +28,47 @@
 #define SM_DEC  0x00002000
 #define RS_IN   0x00000200
 #define RS_OUT  0x00000300
-#define TM_BURST 0x0000080
-#define TS_8    0x00000010
-#define TS_16   0x00000020
-#define TS_32   0x00000030
-#define TS_64   0x00000000
 #define TS_BLK  0x00000040
 #define CHCR_DE 0x00000001
 #define CHCR_TE 0x00000002
 #define CHCR_IE 0x00000004
 
-/* Define the default configuration for dual address memory-memory transfer.
- * The 0x400 value represents auto-request, external->external.
- */
-#define RS_DUAL (DM_INC | SM_INC | 0x400 | TS_32)
-
-#define DMAOR_COD       0x00000008
+/* DMAOR definitions */
 #define DMAOR_AE        0x00000004
 #define DMAOR_NMIF      0x00000002
 #define DMAOR_DME       0x00000001
 
+/*
+ * Define the default configuration for dual address memory-memory transfer.
+ * The 0x400 value represents auto-request, external->external.
+ */
+#define RS_DUAL (DM_INC | SM_INC | 0x400 | TS_32)
+
 #define MAX_DMAC_CHANNELS       (CONFIG_NR_ONCHIP_DMA_CHANNELS)
 
+/*
+ * Subtypes that have fewer channels than this simply need to change
+ * CONFIG_NR_ONCHIP_DMA_CHANNELS. Likewise, subtypes with a larger number
+ * of channels should expand on this.
+ *
+ * For most subtypes we can easily figure these values out with some
+ * basic calculation, unfortunately on other subtypes these are more
+ * scattered, so we just leave it unrolled for simplicity.
+ */
+#define SAR     ((unsigned long[]){SH_DMAC_BASE + 0x00, SH_DMAC_BASE + 0x10, \
+                                   SH_DMAC_BASE + 0x20, SH_DMAC_BASE + 0x30, \
+                                   SH_DMAC_BASE + 0x50, SH_DMAC_BASE + 0x60})
+#define DAR     ((unsigned long[]){SH_DMAC_BASE + 0x04, SH_DMAC_BASE + 0x14, \
+                                   SH_DMAC_BASE + 0x24, SH_DMAC_BASE + 0x34, \
+                                   SH_DMAC_BASE + 0x54, SH_DMAC_BASE + 0x64})
+#define DMATCR  ((unsigned long[]){SH_DMAC_BASE + 0x08, SH_DMAC_BASE + 0x18, \
+                                   SH_DMAC_BASE + 0x28, SH_DMAC_BASE + 0x38, \
+                                   SH_DMAC_BASE + 0x58, SH_DMAC_BASE + 0x68})
+#define CHCR    ((unsigned long[]){SH_DMAC_BASE + 0x0c, SH_DMAC_BASE + 0x1c, \
+                                   SH_DMAC_BASE + 0x2c, SH_DMAC_BASE + 0x3c, \
+                                   SH_DMAC_BASE + 0x5c, SH_DMAC_BASE + 0x6c})
+
+#define DMAOR   (SH_DMAC_BASE + 0x40)
+
 #endif /* __DMA_SH_H */
 
diff --git a/arch/sh/drivers/dma/dma-sysfs.c b/arch/sh/drivers/dma/dma-sysfs.c
index 6e3b58bd8795..70a5d82eb2f8 100644
--- a/arch/sh/drivers/dma/dma-sysfs.c
+++ b/arch/sh/drivers/dma/dma-sysfs.c
@@ -3,7 +3,7 @@
  *
  * sysfs interface for SH DMA API
  *
- * Copyright (C) 2004  Paul Mundt
+ * Copyright (C) 2004, 2005  Paul Mundt
  *
  * 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
@@ -12,7 +12,9 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/sysdev.h>
+#include <linux/platform_device.h>
 #include <linux/module.h>
+#include <linux/err.h>
 #include <linux/string.h>
 #include <asm/dma.h>
 
@@ -77,7 +79,7 @@ static ssize_t dma_store_config(struct sys_device *dev,
         unsigned long config;
 
         config = simple_strtoul(buf, NULL, 0);
-        dma_configure_channel(channel->chan, config);
+        dma_configure_channel(channel->vchan, config);
 
         return count;
 }
@@ -111,12 +113,13 @@ static SYSDEV_ATTR(field, S_IRUGO, dma_show_##field, NULL);
 dma_ro_attr(count, "0x%08x\n");
 dma_ro_attr(flags, "0x%08lx\n");
 
-int __init dma_create_sysfs_files(struct dma_channel *chan)
+int dma_create_sysfs_files(struct dma_channel *chan, struct dma_info *info)
 {
         struct sys_device *dev = &chan->dev;
+        char name[16];
         int ret;
 
-        dev->id  = chan->chan;
+        dev->id  = chan->vchan;
         dev->cls = &dma_sysclass;
 
         ret = sysdev_register(dev);
@@ -129,6 +132,24 @@ int __init dma_create_sysfs_files(struct dma_channel *chan)
         sysdev_create_file(dev, &attr_flags);
         sysdev_create_file(dev, &attr_config);
 
-        return 0;
+        snprintf(name, sizeof(name), "dma%d", chan->chan);
+        return sysfs_create_link(&info->pdev->dev.kobj, &dev->kobj, name);
+}
+
+void dma_remove_sysfs_files(struct dma_channel *chan, struct dma_info *info)
+{
+        struct sys_device *dev = &chan->dev;
+        char name[16];
+
+        sysdev_remove_file(dev, &attr_dev_id);
+        sysdev_remove_file(dev, &attr_count);
+        sysdev_remove_file(dev, &attr_mode);
+        sysdev_remove_file(dev, &attr_flags);
+        sysdev_remove_file(dev, &attr_config);
+
+        snprintf(name, sizeof(name), "dma%d", chan->chan);
+        sysfs_remove_link(&info->pdev->dev.kobj, name);
+
+        sysdev_unregister(dev);
 }
 
diff --git a/arch/sh/kernel/Makefile b/arch/sh/kernel/Makefile
index 8b819698df14..7a86eeb22655 100644
--- a/arch/sh/kernel/Makefile
+++ b/arch/sh/kernel/Makefile
@@ -17,6 +17,4 @@ obj-$(CONFIG_SH_KGDB)		+= kgdb_stub.o kgdb_jmp.o
 obj-$(CONFIG_SH_CPU_FREQ)       += cpufreq.o
 obj-$(CONFIG_MODULES)           += module.o
 obj-$(CONFIG_EARLY_PRINTK)      += early_printk.o
-
-USE_STANDARD_AS_RULE := true
-
+obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
diff --git a/arch/sh/kernel/cpu/Makefile b/arch/sh/kernel/cpu/Makefile
index cd43714df61a..5bfc33bec5d0 100644
--- a/arch/sh/kernel/cpu/Makefile
+++ b/arch/sh/kernel/cpu/Makefile
@@ -2,15 +2,12 @@
 # Makefile for the Linux/SuperH CPU-specifc backends.
 #
 
-obj-y   := irq_ipr.o irq_imask.o init.o bus.o
+obj-y   += irq/ init.o bus.o clock.o
 
 obj-$(CONFIG_CPU_SH2)           += sh2/
 obj-$(CONFIG_CPU_SH3)           += sh3/
 obj-$(CONFIG_CPU_SH4)           += sh4/
 
-obj-$(CONFIG_SH_RTC)            += rtc.o
+obj-$(CONFIG_SH_RTC)            += rtc.o
 obj-$(CONFIG_UBC_WAKEUP)        += ubc.o
-obj-$(CONFIG_SH_ADC)            += adc.o
-
-USE_STANDARD_AS_RULE := true
-
+obj-$(CONFIG_SH_ADC)            += adc.o
diff --git a/arch/sh/kernel/cpu/bus.c b/arch/sh/kernel/cpu/bus.c
index d4fee2a79373..fc6c4bd40c65 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)
@@ -107,6 +109,8 @@ int sh_device_register(struct sh_dev *dev)
         /* This is needed for USB OHCI to work */
         if (dev->dma_mask)
                 dev->dev.dma_mask = dev->dma_mask;
+        if (dev->coherent_dma_mask)
+                dev->dev.coherent_dma_mask = dev->coherent_dma_mask;
 
         snprintf(dev->dev.bus_id, BUS_ID_SIZE, "%s%u",
                  dev->name, dev->dev_id);
@@ -133,8 +137,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/sh/kernel/cpu/clock.c b/arch/sh/kernel/cpu/clock.c
new file mode 100644
index 000000000000..989e7fdd524d
--- /dev/null
+++ b/arch/sh/kernel/cpu/clock.c
@@ -0,0 +1,287 @@
+/*
+ * arch/sh/kernel/cpu/clock.c - SuperH clock framework
+ *
+ *  Copyright (C) 2005  Paul Mundt
+ *
+ * This clock framework is derived from the OMAP version by:
+ *
+ *      Copyright (C) 2004 Nokia Corporation
+ *      Written by Tuukka Tikkanen <tuukka.tikkanen@elektrobit.com>
+ *
+ * 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.
+ */
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/list.h>
+#include <linux/kref.h>
+#include <linux/seq_file.h>
+#include <linux/err.h>
+#include <asm/clock.h>
+#include <asm/timer.h>
+
+static LIST_HEAD(clock_list);
+static DEFINE_SPINLOCK(clock_lock);
+static DECLARE_MUTEX(clock_list_sem);
+
+/*
+ * Each subtype is expected to define the init routines for these clocks,
+ * as each subtype (or processor family) will have these clocks at the
+ * very least. These are all provided through the CPG, which even some of
+ * the more quirky parts (such as ST40, SH4-202, etc.) still have.
+ *
+ * The processor-specific code is expected to register any additional
+ * clock sources that are of interest.
+ */
+static struct clk master_clk = {
+        .name           = "master_clk",
+        .flags          = CLK_ALWAYS_ENABLED | CLK_RATE_PROPAGATES,
+#ifdef CONFIG_SH_PCLK_FREQ_BOOL
+        .rate           = CONFIG_SH_PCLK_FREQ,
+#endif
+};
+
+static struct clk module_clk = {
+        .name           = "module_clk",
+        .parent         = &master_clk,
+        .flags          = CLK_ALWAYS_ENABLED | CLK_RATE_PROPAGATES,
+};
+
+static struct clk bus_clk = {
+        .name           = "bus_clk",
+        .parent         = &master_clk,
+        .flags          = CLK_ALWAYS_ENABLED | CLK_RATE_PROPAGATES,
+};
+
+static struct clk cpu_clk = {
+        .name           = "cpu_clk",
+        .parent         = &master_clk,
+        .flags          = CLK_ALWAYS_ENABLED,
+};
+
+/*
+ * The ordering of these clocks matters, do not change it.
+ */
+static struct clk *onchip_clocks[] = {
+        &master_clk,
+        &module_clk,
+        &bus_clk,
+        &cpu_clk,
+};
+
+static void propagate_rate(struct clk *clk)
+{
+        struct clk *clkp;
+
+        list_for_each_entry(clkp, &clock_list, node) {
+                if (likely(clkp->parent != clk))
+                        continue;
+                if (likely(clkp->ops && clkp->ops->recalc))
+                        clkp->ops->recalc(clkp);
+        }
+}
+
+int __clk_enable(struct clk *clk)
+{
+        /*
+         * See if this is the first time we're enabling the clock, some
+         * clocks that are always enabled still require "special"
+         * initialization. This is especially true if the clock mode
+         * changes and the clock needs to hunt for the proper set of
+         * divisors to use before it can effectively recalc.
+         */
+        if (unlikely(atomic_read(&clk->kref.refcount) == 1))
+                if (clk->ops && clk->ops->init)
+                        clk->ops->init(clk);
+
+        if (clk->flags & CLK_ALWAYS_ENABLED)
+                return 0;
+
+        if (likely(clk->ops && clk->ops->enable))
+                clk->ops->enable(clk);
+
+        kref_get(&clk->kref);
+        return 0;
+}
+
+int clk_enable(struct clk *clk)
+{
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&clock_lock, flags);
+        ret = __clk_enable(clk);
+        spin_unlock_irqrestore(&clock_lock, flags);
+
+        return ret;
+}
+
+static void clk_kref_release(struct kref *kref)
+{
+        /* Nothing to do */
+}
+
+void __clk_disable(struct clk *clk)
+{
+        if (clk->flags & CLK_ALWAYS_ENABLED)
+                return;
+
+        kref_put(&clk->kref, clk_kref_release);
+}
+
+void clk_disable(struct clk *clk)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&clock_lock, flags);
+        __clk_disable(clk);
+        spin_unlock_irqrestore(&clock_lock, flags);
+}
+
+int clk_register(struct clk *clk)
+{
+        down(&clock_list_sem);
+
+        list_add(&clk->node, &clock_list);
+        kref_init(&clk->kref);
+
+        up(&clock_list_sem);
+
+        return 0;
+}
+
+void clk_unregister(struct clk *clk)
+{
+        down(&clock_list_sem);
+        list_del(&clk->node);
+        up(&clock_list_sem);
+}
+
+inline unsigned long clk_get_rate(struct clk *clk)
+{
+        return clk->rate;
+}
+
+int clk_set_rate(struct clk *clk, unsigned long rate)
+{
+        int ret = -EOPNOTSUPP;
+
+        if (likely(clk->ops && clk->ops->set_rate)) {
+                unsigned long flags;
+
+                spin_lock_irqsave(&clock_lock, flags);
+                ret = clk->ops->set_rate(clk, rate);
+                spin_unlock_irqrestore(&clock_lock, flags);
+        }
+
+        if (unlikely(clk->flags & CLK_RATE_PROPAGATES))
+                propagate_rate(clk);
+
+        return ret;
+}
+
+void clk_recalc_rate(struct clk *clk)
+{
+        if (likely(clk->ops && clk->ops->recalc)) {
+                unsigned long flags;
+
+                spin_lock_irqsave(&clock_lock, flags);
+                clk->ops->recalc(clk);
+                spin_unlock_irqrestore(&clock_lock, flags);
+        }
+
+        if (unlikely(clk->flags & CLK_RATE_PROPAGATES))
+                propagate_rate(clk);
+}
+
+struct clk *clk_get(const char *id)
+{
+        struct clk *p, *clk = ERR_PTR(-ENOENT);
+
+        down(&clock_list_sem);
+        list_for_each_entry(p, &clock_list, node) {
+                if (strcmp(id, p->name) == 0 && try_module_get(p->owner)) {
+                        clk = p;
+                        break;
+                }
+        }
+        up(&clock_list_sem);
+
+        return clk;
+}
+
+void clk_put(struct clk *clk)
+{
+        if (clk && !IS_ERR(clk))
+                module_put(clk->owner);
+}
+
+void __init __attribute__ ((weak))
+arch_init_clk_ops(struct clk_ops **ops, int type)
+{
+}
+
+int __init clk_init(void)
+{
+        int i, ret = 0;
+
+        if (unlikely(!master_clk.rate))
+                /*
+                 * NOTE: This will break if the default divisor has been
+                 * changed.
+                 *
+                 * No one should be changing the default on us however,
+                 * expect that a sane value for CONFIG_SH_PCLK_FREQ will
+                 * be defined in the event of a different divisor.
+                 */
+                master_clk.rate = get_timer_frequency() * 4;
+
+        for (i = 0; i < ARRAY_SIZE(onchip_clocks); i++) {
+                struct clk *clk = onchip_clocks[i];
+
+                arch_init_clk_ops(&clk->ops, i);
+                ret |= clk_register(clk);
+                clk_enable(clk);
+        }
+
+        /* Kick the child clocks.. */
+        propagate_rate(&master_clk);
+        propagate_rate(&bus_clk);
+
+        return ret;
+}
+
+int show_clocks(struct seq_file *m)
+{
+        struct clk *clk;
+
+        list_for_each_entry_reverse(clk, &clock_list, node) {
+                unsigned long rate = clk_get_rate(clk);
+
+                /*
+                 * Don't bother listing dummy clocks with no ancestry
+                 * that only support enable and disable ops.
+                 */
+                if (unlikely(!rate && !clk->parent))
+                        continue;
+
+                seq_printf(m, "%-12s\t: %ld.%02ldMHz\n", clk->name,
+                           rate / 1000000, (rate % 1000000) / 10000);
+        }
+
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(clk_register);
+EXPORT_SYMBOL_GPL(clk_unregister);
+EXPORT_SYMBOL_GPL(clk_get);
+EXPORT_SYMBOL_GPL(clk_put);
+EXPORT_SYMBOL_GPL(clk_enable);
+EXPORT_SYMBOL_GPL(clk_disable);
+EXPORT_SYMBOL_GPL(__clk_enable);
+EXPORT_SYMBOL_GPL(__clk_disable);
+EXPORT_SYMBOL_GPL(clk_get_rate);
+EXPORT_SYMBOL_GPL(clk_set_rate);
+EXPORT_SYMBOL_GPL(clk_recalc_rate);
diff --git a/arch/sh/kernel/cpu/irq/Makefile b/arch/sh/kernel/cpu/irq/Makefile
new file mode 100644
index 000000000000..e3cccea15e1d
--- /dev/null
+++ b/arch/sh/kernel/cpu/irq/Makefile
@@ -0,0 +1,7 @@
+#
+# Makefile for the Linux/SuperH CPU-specifc IRQ handlers.
+#
+obj-y   += ipr.o imask.o
+
+obj-$(CONFIG_CPU_HAS_PINT_IRQ)  += pint.o
+obj-$(CONFIG_CPU_HAS_INTC2_IRQ) += intc2.o
diff --git a/arch/sh/kernel/cpu/irq_imask.c b/arch/sh/kernel/cpu/irq/imask.c
index a963d00a971e..baed9a550d39 100644
--- a/arch/sh/kernel/cpu/irq_imask.c
+++ b/arch/sh/kernel/cpu/irq/imask.c
@@ -1,16 +1,12 @@
-/* $Id: irq_imask.c,v 1.1.2.1 2002/11/17 10:53:43 mrbrown Exp $
- *
- * linux/arch/sh/kernel/irq_imask.c
+/*
+ * arch/sh/kernel/cpu/irq/imask.c
  *
  * Copyright (C) 1999, 2000  Niibe Yutaka
  *
  * Simple interrupt handling using IMASK of SR register.
  *
  */
-
 /* NOTE: Will not work on level 15 */
-
-
 #include <linux/ptrace.h>
 #include <linux/errno.h>
 #include <linux/kernel_stat.h>
@@ -19,13 +15,11 @@
 #include <linux/interrupt.h>
 #include <linux/init.h>
 #include <linux/bitops.h>
-
-#include <asm/system.h>
-#include <asm/irq.h>
-
 #include <linux/spinlock.h>
 #include <linux/cache.h>
 #include <linux/irq.h>
+#include <asm/system.h>
+#include <asm/irq.h>
 
 /* Bitmap of IRQ masked */
 static unsigned long imask_mask = 0x7fff;
@@ -40,7 +34,7 @@ static void end_imask_irq(unsigned int irq);
 #define IMASK_PRIORITY  15
 
 static unsigned int startup_imask_irq(unsigned int irq)
-{ 
+{
         /* Nothing to do */
         return 0; /* never anything pending */
 }
diff --git a/arch/sh/kernel/cpu/irq/intc2.c b/arch/sh/kernel/cpu/irq/intc2.c
new file mode 100644
index 000000000000..06e8afab32e4
--- /dev/null
+++ b/arch/sh/kernel/cpu/irq/intc2.c
@@ -0,0 +1,284 @@
+/*
+ * Interrupt handling for INTC2-based IRQ.
+ *
+ * Copyright (C) 2001 David J. Mckay (david.mckay@st.com)
+ * Copyright (C) 2005, 2006 Paul Mundt (lethal@linux-sh.org)
+ *
+ * May be copied or modified under the terms of the GNU General Public
+ * License.  See linux/COPYING for more information.
+ *
+ * These are the "new Hitachi style" interrupts, as present on the
+ * Hitachi 7751, the STM ST40 STB1, SH7760, and SH7780.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/irq.h>
+#include <asm/system.h>
+#include <asm/io.h>
+#include <asm/machvec.h>
+
+struct intc2_data {
+        unsigned char msk_offset;
+        unsigned char msk_shift;
+
+        int (*clear_irq) (int);
+};
+
+static struct intc2_data intc2_data[NR_INTC2_IRQS];
+
+static void enable_intc2_irq(unsigned int irq);
+static void disable_intc2_irq(unsigned int irq);
+
+/* shutdown is same as "disable" */
+#define shutdown_intc2_irq disable_intc2_irq
+
+static void mask_and_ack_intc2(unsigned int);
+static void end_intc2_irq(unsigned int irq);
+
+static unsigned int startup_intc2_irq(unsigned int irq)
+{
+        enable_intc2_irq(irq);
+        return 0; /* never anything pending */
+}
+
+static struct hw_interrupt_type intc2_irq_type = {
+        .typename       = "INTC2-IRQ",
+        .startup        = startup_intc2_irq,
+        .shutdown       = shutdown_intc2_irq,
+        .enable         = enable_intc2_irq,
+        .disable        = disable_intc2_irq,
+        .ack            = mask_and_ack_intc2,
+        .end            = end_intc2_irq
+};
+
+static void disable_intc2_irq(unsigned int irq)
+{
+        int irq_offset = irq - INTC2_FIRST_IRQ;
+        int msk_shift, msk_offset;
+
+        /* Sanity check */
+        if (unlikely(irq_offset < 0 || irq_offset >= NR_INTC2_IRQS))
+                return;
+
+        msk_shift = intc2_data[irq_offset].msk_shift;
+        msk_offset = intc2_data[irq_offset].msk_offset;
+
+        ctrl_outl(1 << msk_shift,
+                  INTC2_BASE + INTC2_INTMSK_OFFSET + msk_offset);
+}
+
+static void enable_intc2_irq(unsigned int irq)
+{
+        int irq_offset = irq - INTC2_FIRST_IRQ;
+        int msk_shift, msk_offset;
+
+        /* Sanity check */
+        if (unlikely(irq_offset < 0 || irq_offset >= NR_INTC2_IRQS))
+                return;
+
+        msk_shift = intc2_data[irq_offset].msk_shift;
+        msk_offset = intc2_data[irq_offset].msk_offset;
+
+        ctrl_outl(1 << msk_shift,
+                  INTC2_BASE + INTC2_INTMSKCLR_OFFSET + msk_offset);
+}
+
+static void mask_and_ack_intc2(unsigned int irq)
+{
+        disable_intc2_irq(irq);
+}
+
+static void end_intc2_irq(unsigned int irq)
+{
+        if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS)))
+                enable_intc2_irq(irq);
+
+        if (unlikely(intc2_data[irq - INTC2_FIRST_IRQ].clear_irq))
+                intc2_data[irq - INTC2_FIRST_IRQ].clear_irq(irq);
+}
+
+/*
+ * Setup an INTC2 style interrupt.
+ * NOTE: Unlike IPR interrupts, parameters are not shifted by this code,
+ * allowing the use of the numbers straight out of the datasheet.
+ * For example:
+ *    PIO1 which is INTPRI00[19,16] and INTMSK00[13]
+ * would be:               ^     ^             ^  ^
+ *                         |     |             |  |
+ *    make_intc2_irq(84,   0,   16,            0, 13);
+ */
+void make_intc2_irq(unsigned int irq,
+                    unsigned int ipr_offset, unsigned int ipr_shift,
+                    unsigned int msk_offset, unsigned int msk_shift,
+                    unsigned int priority)
+{
+        int irq_offset = irq - INTC2_FIRST_IRQ;
+        unsigned int flags;
+        unsigned long ipr;
+
+        if (unlikely(irq_offset < 0 || irq_offset >= NR_INTC2_IRQS))
+                return;
+
+        disable_irq_nosync(irq);
+
+        /* Fill the data we need */
+        intc2_data[irq_offset].msk_offset = msk_offset;
+        intc2_data[irq_offset].msk_shift  = msk_shift;
+        intc2_data[irq_offset].clear_irq = NULL;
+
+        /* Set the priority level */
+        local_irq_save(flags);
+
+        ipr = ctrl_inl(INTC2_BASE + INTC2_INTPRI_OFFSET + ipr_offset);
+        ipr &= ~(0xf << ipr_shift);
+        ipr |= priority << ipr_shift;
+        ctrl_outl(ipr, INTC2_BASE + INTC2_INTPRI_OFFSET + ipr_offset);
+
+        local_irq_restore(flags);
+
+        irq_desc[irq].handler = &intc2_irq_type;
+
+        disable_intc2_irq(irq);
+}
+
+static struct intc2_init {
+        unsigned short irq;
+        unsigned char ipr_offset, ipr_shift;
+        unsigned char msk_offset, msk_shift;
+        unsigned char priority;
+} intc2_init_data[]  __initdata = {
+#if defined(CONFIG_CPU_SUBTYPE_ST40)
+        {64,  0,  0, 0,  0, 13},        /* PCI serr */
+        {65,  0,  4, 0,  1, 13},        /* PCI err */
+        {66,  0,  4, 0,  2, 13},        /* PCI ad */
+        {67,  0,  4, 0,  3, 13},        /* PCI pwd down */
+        {72,  0,  8, 0,  5, 13},        /* DMAC INT0 */
+        {73,  0,  8, 0,  6, 13},        /* DMAC INT1 */
+        {74,  0,  8, 0,  7, 13},        /* DMAC INT2 */
+        {75,  0,  8, 0,  8, 13},        /* DMAC INT3 */
+        {76,  0,  8, 0,  9, 13},        /* DMAC INT4 */
+        {78,  0,  8, 0, 11, 13},        /* DMAC ERR */
+        {80,  0, 12, 0, 12, 13},        /* PIO0 */
+        {84,  0, 16, 0, 13, 13},        /* PIO1 */
+        {88,  0, 20, 0, 14, 13},        /* PIO2 */
+        {112, 4,  0, 4,  0, 13},        /* Mailbox */
+ #ifdef CONFIG_CPU_SUBTYPE_ST40GX1
+        {116, 4,  4, 4,  4, 13},        /* SSC0 */
+        {120, 4,  8, 4,  8, 13},        /* IR Blaster */
+        {124, 4, 12, 4, 12, 13},        /* USB host */
+        {128, 4, 16, 4, 16, 13},        /* Video processor BLITTER */
+        {132, 4, 20, 4, 20, 13},        /* UART0 */
+        {134, 4, 20, 4, 22, 13},        /* UART2 */
+        {136, 4, 24, 4, 24, 13},        /* IO_PIO0 */
+        {140, 4, 28, 4, 28, 13},        /* EMPI */
+        {144, 8,  0, 8,  0, 13},        /* MAFE */
+        {148, 8,  4, 8,  4, 13},        /* PWM */
+        {152, 8,  8, 8,  8, 13},        /* SSC1 */
+        {156, 8, 12, 8, 12, 13},        /* IO_PIO1 */
+        {160, 8, 16, 8, 16, 13},        /* USB target */
+        {164, 8, 20, 8, 20, 13},        /* UART1 */
+        {168, 8, 24, 8, 24, 13},        /* Teletext */
+        {172, 8, 28, 8, 28, 13},        /* VideoSync VTG */
+        {173, 8, 28, 8, 29, 13},        /* VideoSync DVP0 */
+        {174, 8, 28, 8, 30, 13},        /* VideoSync DVP1 */
+#endif
+#elif defined(CONFIG_CPU_SUBTYPE_SH7760)
+/*
+ * SH7760 INTC2-Style interrupts, vectors IRQ48-111 INTEVT 0x800-0xFE0
+ */
+        /* INTPRIO0 | INTMSK0 */
+        {48,  0, 28, 0, 31,  3},        /* IRQ 4 */
+        {49,  0, 24, 0, 30,  3},        /* IRQ 3 */
+        {50,  0, 20, 0, 29,  3},        /* IRQ 2 */
+        {51,  0, 16, 0, 28,  3},        /* IRQ 1 */
+        /* 52-55 (INTEVT 0x880-0x8E0) unused/reserved */
+        /* INTPRIO4 | INTMSK0 */
+        {56,  4, 28, 0, 25,  3},        /* HCAN2_CHAN0 */
+        {57,  4, 24, 0, 24,  3},        /* HCAN2_CHAN1 */
+        {58,  4, 20, 0, 23,  3},        /* I2S_CHAN0   */
+        {59,  4, 16, 0, 22,  3},        /* I2S_CHAN1   */
+        {60,  4, 12, 0, 21,  3},        /* AC97_CHAN0  */
+        {61,  4,  8, 0, 20,  3},        /* AC97_CHAN1  */
+        {62,  4,  4, 0, 19,  3},        /* I2C_CHAN0   */
+        {63,  4,  0, 0, 18,  3},        /* I2C_CHAN1   */
+        /* INTPRIO8 | INTMSK0 */
+        {52,  8, 16, 0, 11,  3},        /* SCIF0_ERI_IRQ */
+        {53,  8, 16, 0, 10,  3},        /* SCIF0_RXI_IRQ */
+        {54,  8, 16, 0,  9,  3},        /* SCIF0_BRI_IRQ */
+        {55,  8, 16, 0,  8,  3},        /* SCIF0_TXI_IRQ */
+        {64,  8, 28, 0, 17,  3},        /* USBHI_IRQ */
+        {65,  8, 24, 0, 16,  3},        /* LCDC      */
+        /* 66, 67 unused */
+        {68,  8, 20, 0, 14, 13},        /* DMABRGI0_IRQ */
+        {69,  8, 20, 0, 13, 13},        /* DMABRGI1_IRQ */
+        {70,  8, 20, 0, 12, 13},        /* DMABRGI2_IRQ */
+        /* 71 unused */
+        {72,  8, 12, 0,  7,  3},        /* SCIF1_ERI_IRQ */
+        {73,  8, 12, 0,  6,  3},        /* SCIF1_RXI_IRQ */
+        {74,  8, 12, 0,  5,  3},        /* SCIF1_BRI_IRQ */
+        {75,  8, 12, 0,  4,  3},        /* SCIF1_TXI_IRQ */
+        {76,  8,  8, 0,  3,  3},        /* SCIF2_ERI_IRQ */
+        {77,  8,  8, 0,  2,  3},        /* SCIF2_RXI_IRQ */
+        {78,  8,  8, 0,  1,  3},        /* SCIF2_BRI_IRQ */
+        {79,  8,  8, 0,  0,  3},        /* SCIF2_TXI_IRQ */
+        /*          | INTMSK4 */
+        {80,  8,  4, 4, 23,  3},        /* SIM_ERI */
+        {81,  8,  4, 4, 22,  3},        /* SIM_RXI */
+        {82,  8,  4, 4, 21,  3},        /* SIM_TXI */
+        {83,  8,  4, 4, 20,  3},        /* SIM_TEI */
+        {84,  8,  0, 4, 19,  3},        /* HSPII */
+        /* INTPRIOC | INTMSK4 */
+        /* 85-87 unused/reserved */
+        {88, 12, 20, 4, 18,  3},        /* MMCI0 */
+        {89, 12, 20, 4, 17,  3},        /* MMCI1 */
+        {90, 12, 20, 4, 16,  3},        /* MMCI2 */
+        {91, 12, 20, 4, 15,  3},        /* MMCI3 */
+        {92, 12, 12, 4,  6,  3},        /* MFI (unsure, bug? in my 7760 manual*/
+        /* 93-107 reserved/undocumented */
+        {108,12,  4, 4,  1,  3},        /* ADC  */
+        {109,12,  0, 4,  0,  3},        /* CMTI */
+        /* 110-111 reserved/unused */
+#elif defined(CONFIG_CPU_SUBTYPE_SH7780)
+        { TIMER_IRQ, 0, 24, 0, INTC_TMU0_MSK, 2},
+#ifdef CONFIG_SH_RTC
+        { RTC_IRQ, 4, 0, 0, INTC_RTC_MSK, TIMER_PRIORITY },
+#endif
+        { SCIF0_ERI_IRQ, 8, 24, 0, INTC_SCIF0_MSK, SCIF0_PRIORITY },
+        { SCIF0_RXI_IRQ, 8, 24, 0, INTC_SCIF0_MSK, SCIF0_PRIORITY },
+        { SCIF0_BRI_IRQ, 8, 24, 0, INTC_SCIF0_MSK, SCIF0_PRIORITY },
+        { SCIF0_TXI_IRQ, 8, 24, 0, INTC_SCIF0_MSK, SCIF0_PRIORITY },
+
+        { SCIF1_ERI_IRQ, 8, 16, 0, INTC_SCIF1_MSK, SCIF1_PRIORITY },
+        { SCIF1_RXI_IRQ, 8, 16, 0, INTC_SCIF1_MSK, SCIF1_PRIORITY },
+        { SCIF1_BRI_IRQ, 8, 16, 0, INTC_SCIF1_MSK, SCIF1_PRIORITY },
+        { SCIF1_TXI_IRQ, 8, 16, 0, INTC_SCIF1_MSK, SCIF1_PRIORITY },
+
+        { PCIC0_IRQ, 0x10,  8, 0, INTC_PCIC0_MSK, PCIC0_PRIORITY },
+        { PCIC1_IRQ, 0x10,  0, 0, INTC_PCIC1_MSK, PCIC1_PRIORITY },
+        { PCIC2_IRQ, 0x14, 24, 0, INTC_PCIC2_MSK, PCIC2_PRIORITY },
+        { PCIC3_IRQ, 0x14, 16, 0, INTC_PCIC3_MSK, PCIC3_PRIORITY },
+        { PCIC4_IRQ, 0x14,  8, 0, INTC_PCIC4_MSK, PCIC4_PRIORITY },
+#endif
+};
+
+void __init init_IRQ_intc2(void)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(intc2_init_data); i++) {
+                struct intc2_init *p = intc2_init_data + i;
+                make_intc2_irq(p->irq, p->ipr_offset, p->ipr_shift,
+                               p-> msk_offset, p->msk_shift, p->priority);
+        }
+}
+
+/* Adds a termination callback to the interrupt */
+void intc2_add_clear_irq(int irq, int (*fn)(int))
+{
+        if (unlikely(irq < INTC2_FIRST_IRQ))
+                return;
+
+        intc2_data[irq - INTC2_FIRST_IRQ].clear_irq = fn;
+}
+
diff --git a/arch/sh/kernel/cpu/irq_ipr.c b/arch/sh/kernel/cpu/irq/ipr.c
index 71f92096132b..fdbd718ae5c6 100644
--- a/arch/sh/kernel/cpu/irq_ipr.c
+++ b/arch/sh/kernel/cpu/irq/ipr.c
@@ -1,6 +1,5 @@
-/* $Id: irq_ipr.c,v 1.1.2.1 2002/11/17 10:53:43 mrbrown Exp $
- *
- * linux/arch/sh/kernel/irq_ipr.c
+/*
+ * arch/sh/kernel/cpu/irq/ipr.c
  *
  * Copyright (C) 1999  Niibe Yutaka & Takeshi Yaegashi
  * Copyright (C) 2000  Kazumoto Kojima
@@ -109,7 +108,8 @@ static void end_ipr_irq(unsigned int irq)
                 enable_ipr_irq(irq);
 }
 
-void make_ipr_irq(unsigned int irq, unsigned int addr, int pos, int priority)
+void make_ipr_irq(unsigned int irq, unsigned int addr, int pos,
+                  int priority, int maskpos)
 {
         disable_irq_nosync(irq);
         ipr_data[irq].addr = addr;
@@ -120,126 +120,47 @@ void make_ipr_irq(unsigned int irq, unsigned int addr, int pos, int priority)
         disable_ipr_irq(irq);
 }
 
-#if defined(CONFIG_CPU_SUBTYPE_SH7705) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7707) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7709)
-static unsigned char pint_map[256];
-static unsigned long portcr_mask = 0;
-
-static void enable_pint_irq(unsigned int irq);
-static void disable_pint_irq(unsigned int irq);
-
-/* shutdown is same as "disable" */
-#define shutdown_pint_irq disable_pint_irq
-
-static void mask_and_ack_pint(unsigned int);
-static void end_pint_irq(unsigned int irq);
-
-static unsigned int startup_pint_irq(unsigned int irq)
-{
-        enable_pint_irq(irq);
-        return 0; /* never anything pending */
-}
-
-static struct hw_interrupt_type pint_irq_type = {
-        .typename = "PINT-IRQ",
-        .startup = startup_pint_irq,
-        .shutdown = shutdown_pint_irq,
-        .enable = enable_pint_irq,
-        .disable = disable_pint_irq,
-        .ack = mask_and_ack_pint,
-        .end = end_pint_irq
-};
-
-static void disable_pint_irq(unsigned int irq)
-{
-        unsigned long val, flags;
-
-        local_irq_save(flags);
-        val = ctrl_inw(INTC_INTER);
-        val &= ~(1 << (irq - PINT_IRQ_BASE));
-        ctrl_outw(val, INTC_INTER);     /* disable PINTn */
-        portcr_mask &= ~(3 << (irq - PINT_IRQ_BASE)*2);
-        local_irq_restore(flags);
-}
-
-static void enable_pint_irq(unsigned int irq)
-{
-        unsigned long val, flags;
-
-        local_irq_save(flags);
-        val = ctrl_inw(INTC_INTER);
-        val |= 1 << (irq - PINT_IRQ_BASE);
-        ctrl_outw(val, INTC_INTER);     /* enable PINTn */
-        portcr_mask |= 3 << (irq - PINT_IRQ_BASE)*2;
-        local_irq_restore(flags);
-}
-
-static void mask_and_ack_pint(unsigned int irq)
-{
-        disable_pint_irq(irq);
-}
-
-static void end_pint_irq(unsigned int irq)
-{
-        if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS)))
-                enable_pint_irq(irq);
-}
-
-void make_pint_irq(unsigned int irq)
-{
-        disable_irq_nosync(irq);
-        irq_desc[irq].handler = &pint_irq_type;
-        disable_pint_irq(irq);
-}
-#endif
-
 void __init init_IRQ(void)
 {
-#if defined(CONFIG_CPU_SUBTYPE_SH7705) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7707) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7709)
-        int i;
-#endif
-
-        make_ipr_irq(TIMER_IRQ, TIMER_IPR_ADDR, TIMER_IPR_POS, TIMER_PRIORITY);
-        make_ipr_irq(TIMER1_IRQ, TIMER1_IPR_ADDR, TIMER1_IPR_POS, TIMER1_PRIORITY);
+#ifndef CONFIG_CPU_SUBTYPE_SH7780
+        make_ipr_irq(TIMER_IRQ, TIMER_IPR_ADDR, TIMER_IPR_POS, TIMER_PRIORITY, 0);
+        make_ipr_irq(TIMER1_IRQ, TIMER1_IPR_ADDR, TIMER1_IPR_POS, TIMER1_PRIORITY, 0);
 #if defined(CONFIG_SH_RTC)
-        make_ipr_irq(RTC_IRQ, RTC_IPR_ADDR, RTC_IPR_POS, RTC_PRIORITY);
+        make_ipr_irq(RTC_IRQ, RTC_IPR_ADDR, RTC_IPR_POS, RTC_PRIORITY, 0);
 #endif
 
 #ifdef SCI_ERI_IRQ
-        make_ipr_irq(SCI_ERI_IRQ, SCI_IPR_ADDR, SCI_IPR_POS, SCI_PRIORITY);
-        make_ipr_irq(SCI_RXI_IRQ, SCI_IPR_ADDR, SCI_IPR_POS, SCI_PRIORITY);
-        make_ipr_irq(SCI_TXI_IRQ, SCI_IPR_ADDR, SCI_IPR_POS, SCI_PRIORITY);
+        make_ipr_irq(SCI_ERI_IRQ, SCI_IPR_ADDR, SCI_IPR_POS, SCI_PRIORITY, 0);
+        make_ipr_irq(SCI_RXI_IRQ, SCI_IPR_ADDR, SCI_IPR_POS, SCI_PRIORITY, 0);
+        make_ipr_irq(SCI_TXI_IRQ, SCI_IPR_ADDR, SCI_IPR_POS, SCI_PRIORITY, 0);
 #endif
 
 #ifdef SCIF1_ERI_IRQ
-        make_ipr_irq(SCIF1_ERI_IRQ, SCIF1_IPR_ADDR, SCIF1_IPR_POS, SCIF1_PRIORITY);
-        make_ipr_irq(SCIF1_RXI_IRQ, SCIF1_IPR_ADDR, SCIF1_IPR_POS, SCIF1_PRIORITY);
-        make_ipr_irq(SCIF1_BRI_IRQ, SCIF1_IPR_ADDR, SCIF1_IPR_POS, SCIF1_PRIORITY);
-        make_ipr_irq(SCIF1_TXI_IRQ, SCIF1_IPR_ADDR, SCIF1_IPR_POS, SCIF1_PRIORITY);
+        make_ipr_irq(SCIF1_ERI_IRQ, SCIF1_IPR_ADDR, SCIF1_IPR_POS, SCIF1_PRIORITY, 0);
+        make_ipr_irq(SCIF1_RXI_IRQ, SCIF1_IPR_ADDR, SCIF1_IPR_POS, SCIF1_PRIORITY, 0);
+        make_ipr_irq(SCIF1_BRI_IRQ, SCIF1_IPR_ADDR, SCIF1_IPR_POS, SCIF1_PRIORITY, 0);
+        make_ipr_irq(SCIF1_TXI_IRQ, SCIF1_IPR_ADDR, SCIF1_IPR_POS, SCIF1_PRIORITY, 0);
 #endif
 
 #if defined(CONFIG_CPU_SUBTYPE_SH7300)
-        make_ipr_irq(SCIF0_IRQ, SCIF0_IPR_ADDR, SCIF0_IPR_POS, SCIF0_PRIORITY);
-        make_ipr_irq(DMTE2_IRQ, DMA1_IPR_ADDR, DMA1_IPR_POS, DMA1_PRIORITY);
-        make_ipr_irq(DMTE3_IRQ, DMA1_IPR_ADDR, DMA1_IPR_POS, DMA1_PRIORITY);
-        make_ipr_irq(VIO_IRQ, VIO_IPR_ADDR, VIO_IPR_POS, VIO_PRIORITY);
+        make_ipr_irq(SCIF0_IRQ, SCIF0_IPR_ADDR, SCIF0_IPR_POS, SCIF0_PRIORITY, 0);
+        make_ipr_irq(DMTE2_IRQ, DMA1_IPR_ADDR, DMA1_IPR_POS, DMA1_PRIORITY, 0);
+        make_ipr_irq(DMTE3_IRQ, DMA1_IPR_ADDR, DMA1_IPR_POS, DMA1_PRIORITY, 0);
+        make_ipr_irq(VIO_IRQ, VIO_IPR_ADDR, VIO_IPR_POS, VIO_PRIORITY, 0);
 #endif
 
 #ifdef SCIF_ERI_IRQ
-        make_ipr_irq(SCIF_ERI_IRQ, SCIF_IPR_ADDR, SCIF_IPR_POS, SCIF_PRIORITY);
-        make_ipr_irq(SCIF_RXI_IRQ, SCIF_IPR_ADDR, SCIF_IPR_POS, SCIF_PRIORITY);
-        make_ipr_irq(SCIF_BRI_IRQ, SCIF_IPR_ADDR, SCIF_IPR_POS, SCIF_PRIORITY);
-        make_ipr_irq(SCIF_TXI_IRQ, SCIF_IPR_ADDR, SCIF_IPR_POS, SCIF_PRIORITY);
+        make_ipr_irq(SCIF_ERI_IRQ, SCIF_IPR_ADDR, SCIF_IPR_POS, SCIF_PRIORITY, 0);
+        make_ipr_irq(SCIF_RXI_IRQ, SCIF_IPR_ADDR, SCIF_IPR_POS, SCIF_PRIORITY, 0);
+        make_ipr_irq(SCIF_BRI_IRQ, SCIF_IPR_ADDR, SCIF_IPR_POS, SCIF_PRIORITY, 0);
+        make_ipr_irq(SCIF_TXI_IRQ, SCIF_IPR_ADDR, SCIF_IPR_POS, SCIF_PRIORITY, 0);
 #endif
 
 #ifdef IRDA_ERI_IRQ
-        make_ipr_irq(IRDA_ERI_IRQ, IRDA_IPR_ADDR, IRDA_IPR_POS, IRDA_PRIORITY);
-        make_ipr_irq(IRDA_RXI_IRQ, IRDA_IPR_ADDR, IRDA_IPR_POS, IRDA_PRIORITY);
-        make_ipr_irq(IRDA_BRI_IRQ, IRDA_IPR_ADDR, IRDA_IPR_POS, IRDA_PRIORITY);
-        make_ipr_irq(IRDA_TXI_IRQ, IRDA_IPR_ADDR, IRDA_IPR_POS, IRDA_PRIORITY);
+        make_ipr_irq(IRDA_ERI_IRQ, IRDA_IPR_ADDR, IRDA_IPR_POS, IRDA_PRIORITY, 0);
+        make_ipr_irq(IRDA_RXI_IRQ, IRDA_IPR_ADDR, IRDA_IPR_POS, IRDA_PRIORITY, 0);
+        make_ipr_irq(IRDA_BRI_IRQ, IRDA_IPR_ADDR, IRDA_IPR_POS, IRDA_PRIORITY, 0);
+        make_ipr_irq(IRDA_TXI_IRQ, IRDA_IPR_ADDR, IRDA_IPR_POS, IRDA_PRIORITY, 0);
 #endif
 
 #if defined(CONFIG_CPU_SUBTYPE_SH7707) || defined(CONFIG_CPU_SUBTYPE_SH7709) || \
@@ -254,86 +175,32 @@ void __init init_IRQ(void)
          * You should set corresponding bits of PFC to "00"
          * to enable these interrupts.
          */
-        make_ipr_irq(IRQ0_IRQ, IRQ0_IPR_ADDR, IRQ0_IPR_POS, IRQ0_PRIORITY);
-        make_ipr_irq(IRQ1_IRQ, IRQ1_IPR_ADDR, IRQ1_IPR_POS, IRQ1_PRIORITY);
-        make_ipr_irq(IRQ2_IRQ, IRQ2_IPR_ADDR, IRQ2_IPR_POS, IRQ2_PRIORITY);
-        make_ipr_irq(IRQ3_IRQ, IRQ3_IPR_ADDR, IRQ3_IPR_POS, IRQ3_PRIORITY);
-        make_ipr_irq(IRQ4_IRQ, IRQ4_IPR_ADDR, IRQ4_IPR_POS, IRQ4_PRIORITY);
-        make_ipr_irq(IRQ5_IRQ, IRQ5_IPR_ADDR, IRQ5_IPR_POS, IRQ5_PRIORITY);
-#if !defined(CONFIG_CPU_SUBTYPE_SH7300)
-        make_ipr_irq(PINT0_IRQ, PINT0_IPR_ADDR, PINT0_IPR_POS, PINT0_PRIORITY);
-        make_ipr_irq(PINT8_IRQ, PINT8_IPR_ADDR, PINT8_IPR_POS, PINT8_PRIORITY);
-        enable_ipr_irq(PINT0_IRQ);
-        enable_ipr_irq(PINT8_IRQ);
+        make_ipr_irq(IRQ0_IRQ, IRQ0_IPR_ADDR, IRQ0_IPR_POS, IRQ0_PRIORITY, 0);
+        make_ipr_irq(IRQ1_IRQ, IRQ1_IPR_ADDR, IRQ1_IPR_POS, IRQ1_PRIORITY, 0);
+        make_ipr_irq(IRQ2_IRQ, IRQ2_IPR_ADDR, IRQ2_IPR_POS, IRQ2_PRIORITY, 0);
+        make_ipr_irq(IRQ3_IRQ, IRQ3_IPR_ADDR, IRQ3_IPR_POS, IRQ3_PRIORITY, 0);
+        make_ipr_irq(IRQ4_IRQ, IRQ4_IPR_ADDR, IRQ4_IPR_POS, IRQ4_PRIORITY, 0);
+        make_ipr_irq(IRQ5_IRQ, IRQ5_IPR_ADDR, IRQ5_IPR_POS, IRQ5_PRIORITY, 0);
+#endif
+#endif
 
-        for(i = 0; i < 16; i++)
-                make_pint_irq(PINT_IRQ_BASE + i);
-        for(i = 0; i < 256; i++)
-        {
-                if(i & 1) pint_map[i] = 0;
-                else if(i & 2) pint_map[i] = 1;
-                else if(i & 4) pint_map[i] = 2;
-                else if(i & 8) pint_map[i] = 3;
-                else if(i & 0x10) pint_map[i] = 4;
-                else if(i & 0x20) pint_map[i] = 5;
-                else if(i & 0x40) pint_map[i] = 6;
-                else if(i & 0x80) pint_map[i] = 7;
-        }
-#endif /* !CONFIG_CPU_SUBTYPE_SH7300 */
-#endif /* CONFIG_CPU_SUBTYPE_SH7707 || CONFIG_CPU_SUBTYPE_SH7709  || CONFIG_CPU_SUBTYPE_SH7300*/
+#ifdef CONFIG_CPU_HAS_PINT_IRQ
+        init_IRQ_pint();
+#endif
 
-#ifdef CONFIG_CPU_SUBTYPE_ST40
+#ifdef CONFIG_CPU_HAS_INTC2_IRQ
         init_IRQ_intc2();
 #endif
-
         /* Perform the machine specific initialisation */
-        if (sh_mv.mv_init_irq != NULL) {
+        if (sh_mv.mv_init_irq != NULL)
                 sh_mv.mv_init_irq();
-        }
 }
-#if defined(CONFIG_CPU_SUBTYPE_SH7707) || defined(CONFIG_CPU_SUBTYPE_SH7709) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7300) || defined(CONFIG_CPU_SUBTYPE_SH7705)
+
+#if !defined(CONFIG_CPU_HAS_PINT_IRQ)
 int ipr_irq_demux(int irq)
 {
-#if !defined(CONFIG_CPU_SUBTYPE_SH7300)
-        unsigned long creg, dreg, d, sav;
-
-        if(irq == PINT0_IRQ)
-        {
-#if defined(CONFIG_CPU_SUBTYPE_SH7707)
-                creg = PORT_PACR;
-                dreg = PORT_PADR;
-#else
-                creg = PORT_PCCR;
-                dreg = PORT_PCDR;
-#endif
-                sav = ctrl_inw(creg);
-                ctrl_outw(sav | portcr_mask, creg);
-                d = (~ctrl_inb(dreg) ^ ctrl_inw(INTC_ICR2)) & ctrl_inw(INTC_INTER) & 0xff;
-                ctrl_outw(sav, creg);
-                if(d == 0) return irq;
-                return PINT_IRQ_BASE + pint_map[d];
-        }
-        else if(irq == PINT8_IRQ)
-        {
-#if defined(CONFIG_CPU_SUBTYPE_SH7707)
-                creg = PORT_PBCR;
-                dreg = PORT_PBDR;
-#else
-                creg = PORT_PFCR;
-                dreg = PORT_PFDR;
-#endif
-                sav = ctrl_inw(creg);
-                ctrl_outw(sav | (portcr_mask >> 16), creg);
-                d = (~ctrl_inb(dreg) ^ (ctrl_inw(INTC_ICR2) >> 8)) & (ctrl_inw(INTC_INTER) >> 8) & 0xff;
-                ctrl_outw(sav, creg);
-                if(d == 0) return irq;
-                return PINT_IRQ_BASE + 8 + pint_map[d];
-        }
-#endif
         return irq;
 }
 #endif
 
 EXPORT_SYMBOL(make_ipr_irq);
-
diff --git a/arch/sh/kernel/cpu/irq/pint.c b/arch/sh/kernel/cpu/irq/pint.c
new file mode 100644
index 000000000000..95d6024fe1ae
--- /dev/null
+++ b/arch/sh/kernel/cpu/irq/pint.c
@@ -0,0 +1,169 @@
+/*
+ * arch/sh/kernel/cpu/irq/pint.c - Interrupt handling for PINT-based IRQs.
+ *
+ * Copyright (C) 1999  Niibe Yutaka & Takeshi Yaegashi
+ * Copyright (C) 2000  Kazumoto Kojima
+ * Copyright (C) 2003 Takashi Kusuda <kusuda-takashi@hitachi-ul.co.jp>
+ *
+ * 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.
+ */
+
+#include <linux/config.h>
+#include <linux/init.h>
+#include <linux/irq.h>
+#include <linux/module.h>
+
+#include <asm/system.h>
+#include <asm/io.h>
+#include <asm/machvec.h>
+
+static unsigned char pint_map[256];
+static unsigned long portcr_mask;
+
+static void enable_pint_irq(unsigned int irq);
+static void disable_pint_irq(unsigned int irq);
+
+/* shutdown is same as "disable" */
+#define shutdown_pint_irq disable_pint_irq
+
+static void mask_and_ack_pint(unsigned int);
+static void end_pint_irq(unsigned int irq);
+
+static unsigned int startup_pint_irq(unsigned int irq)
+{
+        enable_pint_irq(irq);
+        return 0; /* never anything pending */
+}
+
+static struct hw_interrupt_type pint_irq_type = {
+        .typename = "PINT-IRQ",
+        .startup = startup_pint_irq,
+        .shutdown = shutdown_pint_irq,
+        .enable = enable_pint_irq,
+        .disable = disable_pint_irq,
+        .ack = mask_and_ack_pint,
+        .end = end_pint_irq
+};
+
+static void disable_pint_irq(unsigned int irq)
+{
+        unsigned long val, flags;
+
+        local_irq_save(flags);
+        val = ctrl_inw(INTC_INTER);
+        val &= ~(1 << (irq - PINT_IRQ_BASE));
+        ctrl_outw(val, INTC_INTER);     /* disable PINTn */
+        portcr_mask &= ~(3 << (irq - PINT_IRQ_BASE)*2);
+        local_irq_restore(flags);
+}
+
+static void enable_pint_irq(unsigned int irq)
+{
+        unsigned long val, flags;
+
+        local_irq_save(flags);
+        val = ctrl_inw(INTC_INTER);
+        val |= 1 << (irq - PINT_IRQ_BASE);
+        ctrl_outw(val, INTC_INTER);     /* enable PINTn */
+        portcr_mask |= 3 << (irq - PINT_IRQ_BASE)*2;
+        local_irq_restore(flags);
+}
+
+static void mask_and_ack_pint(unsigned int irq)
+{
+        disable_pint_irq(irq);
+}
+
+static void end_pint_irq(unsigned int irq)
+{
+        if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS)))
+                enable_pint_irq(irq);
+}
+
+void make_pint_irq(unsigned int irq)
+{
+        disable_irq_nosync(irq);
+        irq_desc[irq].handler = &pint_irq_type;
+        disable_pint_irq(irq);
+}
+
+void __init init_IRQ_pint(void)
+{
+        int i;
+
+        make_ipr_irq(PINT0_IRQ, PINT0_IPR_ADDR, PINT0_IPR_POS, PINT0_PRIORITY);
+        make_ipr_irq(PINT8_IRQ, PINT8_IPR_ADDR, PINT8_IPR_POS, PINT8_PRIORITY);
+
+        enable_irq(PINT0_IRQ);
+        enable_irq(PINT8_IRQ);
+
+        for(i = 0; i < 16; i++)
+                make_pint_irq(PINT_IRQ_BASE + i);
+
+        for(i = 0; i < 256; i++) {
+                if (i & 1)
+                        pint_map[i] = 0;
+                else if (i & 2)
+                        pint_map[i] = 1;
+                else if (i & 4)
+                        pint_map[i] = 2;
+                else if (i & 8)
+                        pint_map[i] = 3;
+                else if (i & 0x10)
+                        pint_map[i] = 4;
+                else if (i & 0x20)
+                        pint_map[i] = 5;
+                else if (i & 0x40)
+                        pint_map[i] = 6;
+                else if (i & 0x80)
+                        pint_map[i] = 7;
+        }
+}
+
+int ipr_irq_demux(int irq)
+{
+        unsigned long creg, dreg, d, sav;
+
+        if (irq == PINT0_IRQ) {
+#if defined(CONFIG_CPU_SUBTYPE_SH7707)
+                creg = PORT_PACR;
+                dreg = PORT_PADR;
+#else
+                creg = PORT_PCCR;
+                dreg = PORT_PCDR;
+#endif
+                sav = ctrl_inw(creg);
+                ctrl_outw(sav | portcr_mask, creg);
+                d = (~ctrl_inb(dreg) ^ ctrl_inw(INTC_ICR2)) &
+                        ctrl_inw(INTC_INTER) & 0xff;
+                ctrl_outw(sav, creg);
+
+                if (d == 0)
+                        return irq;
+
+                return PINT_IRQ_BASE + pint_map[d];
+        } else if (irq == PINT8_IRQ) {
+#if defined(CONFIG_CPU_SUBTYPE_SH7707)
+                creg = PORT_PBCR;
+                dreg = PORT_PBDR;
+#else
+                creg = PORT_PFCR;
+                dreg = PORT_PFDR;
+#endif
+                sav = ctrl_inw(creg);
+                ctrl_outw(sav | (portcr_mask >> 16), creg);
+                d = (~ctrl_inb(dreg) ^ (ctrl_inw(INTC_ICR2) >> 8)) &
+                        (ctrl_inw(INTC_INTER) >> 8) & 0xff;
+                ctrl_outw(sav, creg);
+
+                if (d == 0)
+                        return irq;
+
+                return PINT_IRQ_BASE + 8 + pint_map[d];
+        }
+
+        return irq;
+}
+
diff --git a/arch/sh/kernel/cpu/sh3/Makefile b/arch/sh/kernel/cpu/sh3/Makefile
index a64532e4dc63..b54dbb9a0c86 100644
--- a/arch/sh/kernel/cpu/sh3/Makefile
+++ b/arch/sh/kernel/cpu/sh3/Makefile
@@ -4,3 +4,10 @@
 
 obj-y   := ex.o probe.o
 
+clock-$(CONFIG_CPU_SH3)                 := clock-sh3.o
+clock-$(CONFIG_CPU_SUBTYPE_SH7300)      := clock-sh7300.o
+clock-$(CONFIG_CPU_SUBTYPE_SH7705)      := clock-sh7705.o
+clock-$(CONFIG_CPU_SUBTYPE_SH7709)      := clock-sh7709.o
+
+obj-y   += $(clock-y)
+
diff --git a/arch/sh/kernel/cpu/sh3/clock-sh3.c b/arch/sh/kernel/cpu/sh3/clock-sh3.c
new file mode 100644
index 000000000000..c3c945958baf
--- /dev/null
+++ b/arch/sh/kernel/cpu/sh3/clock-sh3.c
@@ -0,0 +1,89 @@
+/*
+ * arch/sh/kernel/cpu/sh3/clock-sh3.c
+ *
+ * Generic SH-3 support for the clock framework
+ *
+ *  Copyright (C) 2005  Paul Mundt
+ *
+ * FRQCR parsing hacked out of arch/sh/kernel/time.c
+ *
+ *  Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
+ *  Copyright (C) 2000  Philipp Rumpf <prumpf@tux.org>
+ *  Copyright (C) 2002, 2003, 2004  Paul Mundt
+ *  Copyright (C) 2002  M. R. Brown  <mrbrown@linux-sh.org>
+ *
+ * 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.
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <asm/clock.h>
+#include <asm/freq.h>
+#include <asm/io.h>
+
+static int stc_multipliers[] = { 1, 2, 3, 4, 6, 1, 1, 1 };
+static int ifc_divisors[]    = { 1, 2, 3, 4, 1, 1, 1, 1 };
+static int pfc_divisors[]    = { 1, 2, 3, 4, 6, 1, 1, 1 };
+
+static void master_clk_init(struct clk *clk)
+{
+        int frqcr = ctrl_inw(FRQCR);
+        int idx = ((frqcr & 0x2000) >> 11) | (frqcr & 0x0003);
+
+        clk->rate *= pfc_divisors[idx];
+}
+
+static struct clk_ops sh3_master_clk_ops = {
+        .init           = master_clk_init,
+};
+
+static void module_clk_recalc(struct clk *clk)
+{
+        int frqcr = ctrl_inw(FRQCR);
+        int idx = ((frqcr & 0x2000) >> 11) | (frqcr & 0x0003);
+
+        clk->rate = clk->parent->rate / pfc_divisors[idx];
+}
+
+static struct clk_ops sh3_module_clk_ops = {
+        .recalc         = module_clk_recalc,
+};
+
+static void bus_clk_recalc(struct clk *clk)
+{
+        int frqcr = ctrl_inw(FRQCR);
+        int idx = ((frqcr & 0x8000) >> 13) | ((frqcr & 0x0030) >> 4);
+
+        clk->rate = clk->parent->rate / stc_multipliers[idx];
+}
+
+static struct clk_ops sh3_bus_clk_ops = {
+        .recalc         = bus_clk_recalc,
+};
+
+static void cpu_clk_recalc(struct clk *clk)
+{
+        int frqcr = ctrl_inw(FRQCR);
+        int idx = ((frqcr & 0x4000) >> 12) | ((frqcr & 0x000c) >> 2);
+
+        clk->rate = clk->parent->rate / ifc_divisors[idx];
+}
+
+static struct clk_ops sh3_cpu_clk_ops = {
+        .recalc         = cpu_clk_recalc,
+};
+
+static struct clk_ops *sh3_clk_ops[] = {
+        &sh3_master_clk_ops,
+        &sh3_module_clk_ops,
+        &sh3_bus_clk_ops,
+        &sh3_cpu_clk_ops,
+};
+
+void __init arch_init_clk_ops(struct clk_ops **ops, int idx)
+{
+        if (idx < ARRAY_SIZE(sh3_clk_ops))
+                *ops = sh3_clk_ops[idx];
+}
+
diff --git a/arch/sh/kernel/cpu/sh3/clock-sh7300.c b/arch/sh/kernel/cpu/sh3/clock-sh7300.c
new file mode 100644
index 000000000000..e804174b9625
--- /dev/null
+++ b/arch/sh/kernel/cpu/sh3/clock-sh7300.c
@@ -0,0 +1,78 @@
+/*
+ * arch/sh/kernel/cpu/sh3/clock-sh7300.c
+ *
+ * SH7300 support for the clock framework
+ *
+ *  Copyright (C) 2005  Paul Mundt
+ *
+ * FRQCR parsing hacked out of arch/sh/kernel/time.c
+ *
+ *  Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
+ *  Copyright (C) 2000  Philipp Rumpf <prumpf@tux.org>
+ *  Copyright (C) 2002, 2003, 2004  Paul Mundt
+ *  Copyright (C) 2002  M. R. Brown  <mrbrown@linux-sh.org>
+ *
+ * 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.
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <asm/clock.h>
+#include <asm/freq.h>
+#include <asm/io.h>
+
+static int md_table[] = { 1, 2, 3, 4, 6, 8, 12 };
+
+static void master_clk_init(struct clk *clk)
+{
+        clk->rate *= md_table[ctrl_inw(FRQCR) & 0x0007];
+}
+
+static struct clk_ops sh7300_master_clk_ops = {
+        .init           = master_clk_init,
+};
+
+static void module_clk_recalc(struct clk *clk)
+{
+        int idx = (ctrl_inw(FRQCR) & 0x0007);
+        clk->rate = clk->parent->rate / md_table[idx];
+}
+
+static struct clk_ops sh7300_module_clk_ops = {
+        .recalc         = module_clk_recalc,
+};
+
+static void bus_clk_recalc(struct clk *clk)
+{
+        int idx = (ctrl_inw(FRQCR) & 0x0700) >> 8;
+        clk->rate = clk->parent->rate / md_table[idx];
+}
+
+static struct clk_ops sh7300_bus_clk_ops = {
+        .recalc         = bus_clk_recalc,
+};
+
+static void cpu_clk_recalc(struct clk *clk)
+{
+        int idx = (ctrl_inw(FRQCR) & 0x0070) >> 4;
+        clk->rate = clk->parent->rate / md_table[idx];
+}
+
+static struct clk_ops sh7300_cpu_clk_ops = {
+        .recalc         = cpu_clk_recalc,
+};
+
+static struct clk_ops *sh7300_clk_ops[] = {
+        &sh7300_master_clk_ops,
+        &sh7300_module_clk_ops,
+        &sh7300_bus_clk_ops,
+        &sh7300_cpu_clk_ops,
+};
+
+void __init arch_init_clk_ops(struct clk_ops **ops, int idx)
+{
+        if (idx < ARRAY_SIZE(sh7300_clk_ops))
+                *ops = sh7300_clk_ops[idx];
+}
+
diff --git a/arch/sh/kernel/cpu/sh3/clock-sh7705.c b/arch/sh/kernel/cpu/sh3/clock-sh7705.c
new file mode 100644
index 000000000000..dfdbf3277fd7
--- /dev/null
+++ b/arch/sh/kernel/cpu/sh3/clock-sh7705.c
@@ -0,0 +1,84 @@
+/*
+ * arch/sh/kernel/cpu/sh3/clock-sh7705.c
+ *
+ * SH7705 support for the clock framework
+ *
+ *  Copyright (C) 2005  Paul Mundt
+ *
+ * FRQCR parsing hacked out of arch/sh/kernel/time.c
+ *
+ *  Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
+ *  Copyright (C) 2000  Philipp Rumpf <prumpf@tux.org>
+ *  Copyright (C) 2002, 2003, 2004  Paul Mundt
+ *  Copyright (C) 2002  M. R. Brown  <mrbrown@linux-sh.org>
+ *
+ * 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.
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <asm/clock.h>
+#include <asm/freq.h>
+#include <asm/io.h>
+
+/*
+ * SH7705 uses the same divisors as the generic SH-3 case, it's just the
+ * FRQCR layout that is a bit different..
+ */
+static int stc_multipliers[] = { 1, 2, 3, 4, 6, 1, 1, 1 };
+static int ifc_divisors[]    = { 1, 2, 3, 4, 1, 1, 1, 1 };
+static int pfc_divisors[]    = { 1, 2, 3, 4, 6, 1, 1, 1 };
+
+static void master_clk_init(struct clk *clk)
+{
+        clk->rate *= pfc_divisors[ctrl_inw(FRQCR) & 0x0003];
+}
+
+static struct clk_ops sh7705_master_clk_ops = {
+        .init           = master_clk_init,
+};
+
+static void module_clk_recalc(struct clk *clk)
+{
+        int idx = ctrl_inw(FRQCR) & 0x0003;
+        clk->rate = clk->parent->rate / pfc_divisors[idx];
+}
+
+static struct clk_ops sh7705_module_clk_ops = {
+        .recalc         = module_clk_recalc,
+};
+
+static void bus_clk_recalc(struct clk *clk)
+{
+        int idx = (ctrl_inw(FRQCR) & 0x0300) >> 8;
+        clk->rate = clk->parent->rate / stc_multipliers[idx];
+}
+
+static struct clk_ops sh7705_bus_clk_ops = {
+        .recalc         = bus_clk_recalc,
+};
+
+static void cpu_clk_recalc(struct clk *clk)
+{
+        int idx = (ctrl_inw(FRQCR) & 0x0030) >> 4;
+        clk->rate = clk->parent->rate / ifc_divisors[idx];
+}
+
+static struct clk_ops sh7705_cpu_clk_ops = {
+        .recalc         = cpu_clk_recalc,
+};
+
+static struct clk_ops *sh7705_clk_ops[] = {
+        &sh7705_master_clk_ops,
+        &sh7705_module_clk_ops,
+        &sh7705_bus_clk_ops,
+        &sh7705_cpu_clk_ops,
+};
+
+void __init arch_init_clk_ops(struct clk_ops **ops, int idx)
+{
+        if (idx < ARRAY_SIZE(sh7705_clk_ops))
+                *ops = sh7705_clk_ops[idx];
+}
+
diff --git a/arch/sh/kernel/cpu/sh3/clock-sh7709.c b/arch/sh/kernel/cpu/sh3/clock-sh7709.c
new file mode 100644
index 000000000000..10461a745e5f
--- /dev/null
+++ b/arch/sh/kernel/cpu/sh3/clock-sh7709.c
@@ -0,0 +1,96 @@
+/*
+ * arch/sh/kernel/cpu/sh3/clock-sh7709.c
+ *
+ * SH7709 support for the clock framework
+ *
+ *  Copyright (C) 2005  Andriy Skulysh
+ *
+ * Based on arch/sh/kernel/cpu/sh3/clock-sh7705.c
+ *  Copyright (C) 2005  Paul Mundt
+ *
+ * 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.
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <asm/clock.h>
+#include <asm/freq.h>
+#include <asm/io.h>
+
+static int stc_multipliers[] = { 1, 2, 4, 8, 3, 6, 1, 1 };
+static int ifc_divisors[]    = { 1, 2, 4, 1, 3, 1, 1, 1 };
+static int pfc_divisors[]    = { 1, 2, 4, 1, 3, 6, 1, 1 };
+
+static void set_bus_parent(struct clk *clk)
+{
+        struct clk *bus_clk = clk_get("bus_clk");
+        clk->parent = bus_clk;
+        clk_put(bus_clk);
+}
+
+static void master_clk_init(struct clk *clk)
+{
+        int frqcr = ctrl_inw(FRQCR);
+        int idx = ((frqcr & 0x2000) >> 11) | (frqcr & 0x0003);
+
+        clk->rate *= pfc_divisors[idx];
+}
+
+static struct clk_ops sh7709_master_clk_ops = {
+        .init           = master_clk_init,
+};
+
+static void module_clk_recalc(struct clk *clk)
+{
+        int frqcr = ctrl_inw(FRQCR);
+        int idx = ((frqcr & 0x2000) >> 11) | (frqcr & 0x0003);
+
+        clk->rate = clk->parent->rate / pfc_divisors[idx];
+}
+
+static struct clk_ops sh7709_module_clk_ops = {
+#ifdef CLOCK_MODE_0_1_2_7
+        .init           = set_bus_parent,
+#endif
+        .recalc         = module_clk_recalc,
+};
+
+static void bus_clk_recalc(struct clk *clk)
+{
+        int frqcr = ctrl_inw(FRQCR);
+        int idx = (frqcr & 0x0080) ?
+                ((frqcr & 0x8000) >> 13) | ((frqcr & 0x0030) >> 4) : 1;
+
+        clk->rate = clk->parent->rate * stc_multipliers[idx];
+}
+
+static struct clk_ops sh7709_bus_clk_ops = {
+        .recalc         = bus_clk_recalc,
+};
+
+static void cpu_clk_recalc(struct clk *clk)
+{
+        int frqcr = ctrl_inw(FRQCR);
+        int idx = ((frqcr & 0x4000) >> 12) | ((frqcr & 0x000c) >> 2);
+
+        clk->rate = clk->parent->rate / ifc_divisors[idx];
+}
+
+static struct clk_ops sh7709_cpu_clk_ops = {
+        .init           = set_bus_parent,
+        .recalc         = cpu_clk_recalc,
+};
+
+static struct clk_ops *sh7709_clk_ops[] = {
+        &sh7709_master_clk_ops,
+        &sh7709_module_clk_ops,
+        &sh7709_bus_clk_ops,
+        &sh7709_cpu_clk_ops,
+};
+
+void __init arch_init_clk_ops(struct clk_ops **ops, int idx)
+{
+        if (idx < ARRAY_SIZE(sh7709_clk_ops))
+                *ops = sh7709_clk_ops[idx];
+}
diff --git a/arch/sh/kernel/cpu/sh4/Makefile b/arch/sh/kernel/cpu/sh4/Makefile
index ead1071eac73..3d5cafc71ae3 100644
--- a/arch/sh/kernel/cpu/sh4/Makefile
+++ b/arch/sh/kernel/cpu/sh4/Makefile
@@ -5,6 +5,15 @@
 obj-y   := ex.o probe.o
 
 obj-$(CONFIG_SH_FPU)                    += fpu.o
-obj-$(CONFIG_CPU_SUBTYPE_ST40STB1)      += irq_intc2.o
 obj-$(CONFIG_SH_STORE_QUEUES)           += sq.o
 
+# Primary on-chip clocks (common)
+clock-$(CONFIG_CPU_SH4)                 := clock-sh4.o
+clock-$(CONFIG_CPU_SUBTYPE_SH73180)     := clock-sh73180.o
+clock-$(CONFIG_CPU_SUBTYPE_SH7770)      := clock-sh7770.o
+clock-$(CONFIG_CPU_SUBTYPE_SH7780)      := clock-sh7780.o
+
+# Additional clocks by subtype
+clock-$(CONFIG_CPU_SUBTYPE_SH4_202)     += clock-sh4-202.o
+
+obj-y   += $(clock-y)
diff --git a/arch/sh/kernel/cpu/sh4/clock-sh4-202.c b/arch/sh/kernel/cpu/sh4/clock-sh4-202.c
new file mode 100644
index 000000000000..bfdf5fe8d948
--- /dev/null
+++ b/arch/sh/kernel/cpu/sh4/clock-sh4-202.c
@@ -0,0 +1,179 @@
+/*
+ * arch/sh/kernel/cpu/sh4/clock-sh4-202.c
+ *
+ * Additional SH4-202 support for the clock framework
+ *
+ *  Copyright (C) 2005  Paul Mundt
+ *
+ * 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.
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/err.h>
+#include <asm/clock.h>
+#include <asm/freq.h>
+#include <asm/io.h>
+
+#define CPG2_FRQCR3     0xfe0a0018
+
+static int frqcr3_divisors[] = { 1, 2, 3, 4, 6, 8, 16 };
+static int frqcr3_values[]   = { 0, 1, 2, 3, 4, 5, 6  };
+
+static void emi_clk_recalc(struct clk *clk)
+{
+        int idx = ctrl_inl(CPG2_FRQCR3) & 0x0007;
+        clk->rate = clk->parent->rate / frqcr3_divisors[idx];
+}
+
+static inline int frqcr3_lookup(struct clk *clk, unsigned long rate)
+{
+        int divisor = clk->parent->rate / rate;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(frqcr3_divisors); i++)
+                if (frqcr3_divisors[i] == divisor)
+                        return frqcr3_values[i];
+
+        /* Safe fallback */
+        return 5;
+}
+
+static struct clk_ops sh4202_emi_clk_ops = {
+        .recalc         = emi_clk_recalc,
+};
+
+static struct clk sh4202_emi_clk = {
+        .name           = "emi_clk",
+        .flags          = CLK_ALWAYS_ENABLED,
+        .ops            = &sh4202_emi_clk_ops,
+};
+
+static void femi_clk_recalc(struct clk *clk)
+{
+        int idx = (ctrl_inl(CPG2_FRQCR3) >> 3) & 0x0007;
+        clk->rate = clk->parent->rate / frqcr3_divisors[idx];
+}
+
+static struct clk_ops sh4202_femi_clk_ops = {
+        .recalc         = femi_clk_recalc,
+};
+
+static struct clk sh4202_femi_clk = {
+        .name           = "femi_clk",
+        .flags          = CLK_ALWAYS_ENABLED,
+        .ops            = &sh4202_femi_clk_ops,
+};
+
+static void shoc_clk_init(struct clk *clk)
+{
+        int i;
+
+        /*
+         * For some reason, the shoc_clk seems to be set to some really
+         * insane value at boot (values outside of the allowable frequency
+         * range for instance). We deal with this by scaling it back down
+         * to something sensible just in case.
+         *
+         * Start scaling from the high end down until we find something
+         * that passes rate verification..
+         */
+        for (i = 0; i < ARRAY_SIZE(frqcr3_divisors); i++) {
+                int divisor = frqcr3_divisors[i];
+
+                if (clk->ops->set_rate(clk, clk->parent->rate / divisor) == 0)
+                        break;
+        }
+
+        WARN_ON(i == ARRAY_SIZE(frqcr3_divisors));      /* Undefined clock */
+}
+
+static void shoc_clk_recalc(struct clk *clk)
+{
+        int idx = (ctrl_inl(CPG2_FRQCR3) >> 6) & 0x0007;
+        clk->rate = clk->parent->rate / frqcr3_divisors[idx];
+}
+
+static int shoc_clk_verify_rate(struct clk *clk, unsigned long rate)
+{
+        struct clk *bclk = clk_get("bus_clk");
+        unsigned long bclk_rate = clk_get_rate(bclk);
+
+        clk_put(bclk);
+
+        if (rate > bclk_rate)
+                return 1;
+        if (rate > 66000000)
+                return 1;
+
+        return 0;
+}
+
+static int shoc_clk_set_rate(struct clk *clk, unsigned long rate)
+{
+        unsigned long frqcr3;
+        unsigned int tmp;
+
+        /* Make sure we have something sensible to switch to */
+        if (shoc_clk_verify_rate(clk, rate) != 0)
+                return -EINVAL;
+
+        tmp = frqcr3_lookup(clk, rate);
+
+        frqcr3 = ctrl_inl(CPG2_FRQCR3);
+        frqcr3 &= ~(0x0007 << 6);
+        frqcr3 |= tmp << 6;
+        ctrl_outl(frqcr3, CPG2_FRQCR3);
+
+        clk->rate = clk->parent->rate / frqcr3_divisors[tmp];
+
+        return 0;
+}
+
+static struct clk_ops sh4202_shoc_clk_ops = {
+        .init           = shoc_clk_init,
+        .recalc         = shoc_clk_recalc,
+        .set_rate       = shoc_clk_set_rate,
+};
+
+static struct clk sh4202_shoc_clk = {
+        .name           = "shoc_clk",
+        .flags          = CLK_ALWAYS_ENABLED,
+        .ops            = &sh4202_shoc_clk_ops,
+};
+
+static struct clk *sh4202_onchip_clocks[] = {
+        &sh4202_emi_clk,
+        &sh4202_femi_clk,
+        &sh4202_shoc_clk,
+};
+
+static int __init sh4202_clk_init(void)
+{
+        struct clk *clk = clk_get("master_clk");
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(sh4202_onchip_clocks); i++) {
+                struct clk *clkp = sh4202_onchip_clocks[i];
+
+                clkp->parent = clk;
+                clk_register(clkp);
+                clk_enable(clkp);
+        }
+
+        /*
+         * Now that we have the rest of the clocks registered, we need to
+         * force the parent clock to propagate so that these clocks will
+         * automatically figure out their rate. We cheat by handing the
+         * parent clock its current rate and forcing child propagation.
+         */
+        clk_set_rate(clk, clk_get_rate(clk));
+
+        clk_put(clk);
+
+        return 0;
+}
+
+arch_initcall(sh4202_clk_init);
+
diff --git a/arch/sh/kernel/cpu/sh4/clock-sh4.c b/arch/sh/kernel/cpu/sh4/clock-sh4.c
new file mode 100644
index 000000000000..dca9f87a12d6
--- /dev/null
+++ b/arch/sh/kernel/cpu/sh4/clock-sh4.c
@@ -0,0 +1,80 @@
+/*
+ * arch/sh/kernel/cpu/sh4/clock-sh4.c
+ *
+ * Generic SH-4 support for the clock framework
+ *
+ *  Copyright (C) 2005  Paul Mundt
+ *
+ * FRQCR parsing hacked out of arch/sh/kernel/time.c
+ *
+ *  Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
+ *  Copyright (C) 2000  Philipp Rumpf <prumpf@tux.org>
+ *  Copyright (C) 2002, 2003, 2004  Paul Mundt
+ *  Copyright (C) 2002  M. R. Brown  <mrbrown@linux-sh.org>
+ *
+ * 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.
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <asm/clock.h>
+#include <asm/freq.h>
+#include <asm/io.h>
+
+static int ifc_divisors[] = { 1, 2, 3, 4, 6, 8, 1, 1 };
+#define bfc_divisors ifc_divisors       /* Same */
+static int pfc_divisors[] = { 2, 3, 4, 6, 8, 2, 2, 2 };
+
+static void master_clk_init(struct clk *clk)
+{
+        clk->rate *= pfc_divisors[ctrl_inw(FRQCR) & 0x0007];
+}
+
+static struct clk_ops sh4_master_clk_ops = {
+        .init           = master_clk_init,
+};
+
+static void module_clk_recalc(struct clk *clk)
+{
+        int idx = (ctrl_inw(FRQCR) & 0x0007);
+        clk->rate = clk->parent->rate / pfc_divisors[idx];
+}
+
+static struct clk_ops sh4_module_clk_ops = {
+        .recalc         = module_clk_recalc,
+};
+
+static void bus_clk_recalc(struct clk *clk)
+{
+        int idx = (ctrl_inw(FRQCR) >> 3) & 0x0007;
+        clk->rate = clk->parent->rate / bfc_divisors[idx];
+}
+
+static struct clk_ops sh4_bus_clk_ops = {
+        .recalc         = bus_clk_recalc,
+};
+
+static void cpu_clk_recalc(struct clk *clk)
+{
+        int idx = (ctrl_inw(FRQCR) >> 6) & 0x0007;
+        clk->rate = clk->parent->rate / ifc_divisors[idx];
+}
+
+static struct clk_ops sh4_cpu_clk_ops = {
+        .recalc         = cpu_clk_recalc,
+};
+
+static struct clk_ops *sh4_clk_ops[] = {
+        &sh4_master_clk_ops,
+        &sh4_module_clk_ops,
+        &sh4_bus_clk_ops,
+        &sh4_cpu_clk_ops,
+};
+
+void __init arch_init_clk_ops(struct clk_ops **ops, int idx)
+{
+        if (idx < ARRAY_SIZE(sh4_clk_ops))
+                *ops = sh4_clk_ops[idx];
+}
+
diff --git a/arch/sh/kernel/cpu/sh4/clock-sh73180.c b/arch/sh/kernel/cpu/sh4/clock-sh73180.c
new file mode 100644
index 000000000000..2fa5cb2ae68d
--- /dev/null
+++ b/arch/sh/kernel/cpu/sh4/clock-sh73180.c
@@ -0,0 +1,81 @@
+/*
+ * arch/sh/kernel/cpu/sh4/clock-sh73180.c
+ *
+ * SH73180 support for the clock framework
+ *
+ *  Copyright (C) 2005  Paul Mundt
+ *
+ * FRQCR parsing hacked out of arch/sh/kernel/time.c
+ *
+ *  Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
+ *  Copyright (C) 2000  Philipp Rumpf <prumpf@tux.org>
+ *  Copyright (C) 2002, 2003, 2004  Paul Mundt
+ *  Copyright (C) 2002  M. R. Brown  <mrbrown@linux-sh.org>
+ *
+ * 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.
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <asm/clock.h>
+#include <asm/freq.h>
+#include <asm/io.h>
+
+/*
+ * SH73180 uses a common set of divisors, so this is quite simple..
+ */
+static int divisors[] = { 1, 2, 3, 4, 6, 8, 12, 16 };
+
+static void master_clk_init(struct clk *clk)
+{
+        clk->rate *= divisors[ctrl_inl(FRQCR) & 0x0007];
+}
+
+static struct clk_ops sh73180_master_clk_ops = {
+        .init           = master_clk_init,
+};
+
+static void module_clk_recalc(struct clk *clk)
+{
+        int idx = (ctrl_inl(FRQCR) & 0x0007);
+        clk->rate = clk->parent->rate / divisors[idx];
+}
+
+static struct clk_ops sh73180_module_clk_ops = {
+        .recalc         = module_clk_recalc,
+};
+
+static void bus_clk_recalc(struct clk *clk)
+{
+        int idx = (ctrl_inl(FRQCR) >> 12) & 0x0007;
+        clk->rate = clk->parent->rate / divisors[idx];
+}
+
+static struct clk_ops sh73180_bus_clk_ops = {
+        .recalc         = bus_clk_recalc,
+};
+
+static void cpu_clk_recalc(struct clk *clk)
+{
+        int idx = (ctrl_inl(FRQCR) >> 20) & 0x0007;
+        clk->rate = clk->parent->rate / divisors[idx];
+}
+
+static struct clk_ops sh73180_cpu_clk_ops = {
+        .recalc         = cpu_clk_recalc,
+};
+
+static struct clk_ops *sh73180_clk_ops[] = {
+        &sh73180_master_clk_ops,
+        &sh73180_module_clk_ops,
+        &sh73180_bus_clk_ops,
+        &sh73180_cpu_clk_ops,
+};
+
+void __init arch_init_clk_ops(struct clk_ops **ops, int idx)
+{
+        if (idx < ARRAY_SIZE(sh73180_clk_ops))
+                *ops = sh73180_clk_ops[idx];
+}
+
diff --git a/arch/sh/kernel/cpu/sh4/clock-sh7770.c b/arch/sh/kernel/cpu/sh4/clock-sh7770.c
new file mode 100644
index 000000000000..c8694bac6477
--- /dev/null
+++ b/arch/sh/kernel/cpu/sh4/clock-sh7770.c
@@ -0,0 +1,73 @@
+/*
+ * arch/sh/kernel/cpu/sh4/clock-sh7770.c
+ *
+ * SH7770 support for the clock framework
+ *
+ *  Copyright (C) 2005  Paul Mundt
+ *
+ * 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.
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <asm/clock.h>
+#include <asm/freq.h>
+#include <asm/io.h>
+
+static int ifc_divisors[] = { 1, 1, 1, 1, 1, 1, 1, 1 };
+static int bfc_divisors[] = { 1, 1, 1, 1, 1, 8,12, 1 };
+static int pfc_divisors[] = { 1, 8, 1,10,12,16, 1, 1 };
+
+static void master_clk_init(struct clk *clk)
+{
+        clk->rate *= pfc_divisors[(ctrl_inl(FRQCR) >> 28) & 0x000f];
+}
+
+static struct clk_ops sh7770_master_clk_ops = {
+        .init           = master_clk_init,
+};
+
+static void module_clk_recalc(struct clk *clk)
+{
+        int idx = ((ctrl_inl(FRQCR) >> 28) & 0x000f);
+        clk->rate = clk->parent->rate / pfc_divisors[idx];
+}
+
+static struct clk_ops sh7770_module_clk_ops = {
+        .recalc         = module_clk_recalc,
+};
+
+static void bus_clk_recalc(struct clk *clk)
+{
+        int idx = (ctrl_inl(FRQCR) & 0x000f);
+        clk->rate = clk->parent->rate / bfc_divisors[idx];
+}
+
+static struct clk_ops sh7770_bus_clk_ops = {
+        .recalc         = bus_clk_recalc,
+};
+
+static void cpu_clk_recalc(struct clk *clk)
+{
+        int idx = ((ctrl_inl(FRQCR) >> 24) & 0x000f);
+        clk->rate = clk->parent->rate / ifc_divisors[idx];
+}
+
+static struct clk_ops sh7770_cpu_clk_ops = {
+        .recalc         = cpu_clk_recalc,
+};
+
+static struct clk_ops *sh7770_clk_ops[] = {
+        &sh7770_master_clk_ops,
+        &sh7770_module_clk_ops,
+        &sh7770_bus_clk_ops,
+        &sh7770_cpu_clk_ops,
+};
+
+void __init arch_init_clk_ops(struct clk_ops **ops, int idx)
+{
+        if (idx < ARRAY_SIZE(sh7770_clk_ops))
+                *ops = sh7770_clk_ops[idx];
+}
+
diff --git a/arch/sh/kernel/cpu/sh4/clock-sh7780.c b/arch/sh/kernel/cpu/sh4/clock-sh7780.c
new file mode 100644
index 000000000000..93ad367342c9
--- /dev/null
+++ b/arch/sh/kernel/cpu/sh4/clock-sh7780.c
@@ -0,0 +1,126 @@
+/*
+ * arch/sh/kernel/cpu/sh4/clock-sh7780.c
+ *
+ * SH7780 support for the clock framework
+ *
+ *  Copyright (C) 2005  Paul Mundt
+ *
+ * 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.
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <asm/clock.h>
+#include <asm/freq.h>
+#include <asm/io.h>
+
+static int ifc_divisors[] = { 2, 4 };
+static int bfc_divisors[] = { 1, 1, 1, 8, 12, 16, 24, 1 };
+static int pfc_divisors[] = { 1, 24, 24, 1 };
+static int cfc_divisors[] = { 1, 1, 4, 1, 6, 1, 1, 1 };
+
+static void master_clk_init(struct clk *clk)
+{
+        clk->rate *= pfc_divisors[ctrl_inl(FRQCR) & 0x0003];
+}
+
+static struct clk_ops sh7780_master_clk_ops = {
+        .init           = master_clk_init,
+};
+
+static void module_clk_recalc(struct clk *clk)
+{
+        int idx = (ctrl_inl(FRQCR) & 0x0003);
+        clk->rate = clk->parent->rate / pfc_divisors[idx];
+}
+
+static struct clk_ops sh7780_module_clk_ops = {
+        .recalc         = module_clk_recalc,
+};
+
+static void bus_clk_recalc(struct clk *clk)
+{
+        int idx = ((ctrl_inl(FRQCR) >> 16) & 0x0007);
+        clk->rate = clk->parent->rate / bfc_divisors[idx];
+}
+
+static struct clk_ops sh7780_bus_clk_ops = {
+        .recalc         = bus_clk_recalc,
+};
+
+static void cpu_clk_recalc(struct clk *clk)
+{
+        int idx = ((ctrl_inl(FRQCR) >> 24) & 0x0001);
+        clk->rate = clk->parent->rate / ifc_divisors[idx];
+}
+
+static struct clk_ops sh7780_cpu_clk_ops = {
+        .recalc         = cpu_clk_recalc,
+};
+
+static struct clk_ops *sh7780_clk_ops[] = {
+        &sh7780_master_clk_ops,
+        &sh7780_module_clk_ops,
+        &sh7780_bus_clk_ops,
+        &sh7780_cpu_clk_ops,
+};
+
+void __init arch_init_clk_ops(struct clk_ops **ops, int idx)
+{
+        if (idx < ARRAY_SIZE(sh7780_clk_ops))
+                *ops = sh7780_clk_ops[idx];
+}
+
+static void shyway_clk_recalc(struct clk *clk)
+{
+        int idx = ((ctrl_inl(FRQCR) >> 20) & 0x0007);
+        clk->rate = clk->parent->rate / cfc_divisors[idx];
+}
+
+static struct clk_ops sh7780_shyway_clk_ops = {
+        .recalc         = shyway_clk_recalc,
+};
+
+static struct clk sh7780_shyway_clk = {
+        .name           = "shyway_clk",
+        .flags          = CLK_ALWAYS_ENABLED,
+        .ops            = &sh7780_shyway_clk_ops,
+};
+
+/*
+ * Additional SH7780-specific on-chip clocks that aren't already part of the
+ * clock framework
+ */
+static struct clk *sh7780_onchip_clocks[] = {
+        &sh7780_shyway_clk,
+};
+
+static int __init sh7780_clk_init(void)
+{
+        struct clk *clk = clk_get("master_clk");
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(sh7780_onchip_clocks); i++) {
+                struct clk *clkp = sh7780_onchip_clocks[i];
+
+                clkp->parent = clk;
+                clk_register(clkp);
+                clk_enable(clkp);
+        }
+
+        /*
+         * Now that we have the rest of the clocks registered, we need to
+         * force the parent clock to propagate so that these clocks will
+         * automatically figure out their rate. We cheat by handing the
+         * parent clock its current rate and forcing child propagation.
+         */
+        clk_set_rate(clk, clk_get_rate(clk));
+
+        clk_put(clk);
+
+        return 0;
+}
+
+arch_initcall(sh7780_clk_init);
+
diff --git a/arch/sh/kernel/cpu/sh4/irq_intc2.c b/arch/sh/kernel/cpu/sh4/irq_intc2.c
deleted file mode 100644
index f6b16ba01932..000000000000
--- a/arch/sh/kernel/cpu/sh4/irq_intc2.c
+++ /dev/null
@@ -1,222 +0,0 @@
-/*
- * linux/arch/sh/kernel/irq_intc2.c
- *
- * Copyright (C) 2001 David J. Mckay (david.mckay@st.com)
- *
- * May be copied or modified under the terms of the GNU General Public
- * License.  See linux/COPYING for more information.                            
- *
- * Interrupt handling for INTC2-based IRQ.
- *
- * These are the "new Hitachi style" interrupts, as present on the 
- * Hitachi 7751 and the STM ST40 STB1.
- */
-
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/irq.h>
-
-#include <asm/system.h>
-#include <asm/io.h>
-#include <asm/machvec.h>
-
-
-struct intc2_data {
-        unsigned char msk_offset;
-        unsigned char msk_shift;
-#ifdef CONFIG_CPU_SUBTYPE_ST40
-        int (*clear_irq) (int);
-#endif
-};
-
-
-static struct intc2_data intc2_data[NR_INTC2_IRQS];
-
-static void enable_intc2_irq(unsigned int irq);
-static void disable_intc2_irq(unsigned int irq);
-
-/* shutdown is same as "disable" */
-#define shutdown_intc2_irq disable_intc2_irq
-
-static void mask_and_ack_intc2(unsigned int);
-static void end_intc2_irq(unsigned int irq);
-
-static unsigned int startup_intc2_irq(unsigned int irq)
-{ 
-        enable_intc2_irq(irq);
-        return 0; /* never anything pending */
-}
-
-static struct hw_interrupt_type intc2_irq_type = {
-        .typename = "INTC2-IRQ",
-        .startup = startup_intc2_irq,
-        .shutdown = shutdown_intc2_irq,
-        .enable = enable_intc2_irq,
-        .disable = disable_intc2_irq,
-        .ack = mask_and_ack_intc2,
-        .end = end_intc2_irq
-};
-
-static void disable_intc2_irq(unsigned int irq)
-{
-        int irq_offset = irq - INTC2_FIRST_IRQ;
-        int msk_shift, msk_offset;
-
-        // Sanity check
-        if((irq_offset<0) || (irq_offset>=NR_INTC2_IRQS))
-                return;
-
-        msk_shift = intc2_data[irq_offset].msk_shift;
-        msk_offset = intc2_data[irq_offset].msk_offset;
-
-        ctrl_outl(1<<msk_shift,
-                  INTC2_BASE+INTC2_INTMSK_OFFSET+msk_offset);
-}
-
-static void enable_intc2_irq(unsigned int irq)
-{
-        int irq_offset = irq - INTC2_FIRST_IRQ;
-        int msk_shift, msk_offset;
-
-        /* Sanity check */
-        if((irq_offset<0) || (irq_offset>=NR_INTC2_IRQS))
-                return;
-
-        msk_shift = intc2_data[irq_offset].msk_shift;
-        msk_offset = intc2_data[irq_offset].msk_offset;
-
-        ctrl_outl(1<<msk_shift,
-                  INTC2_BASE+INTC2_INTMSKCLR_OFFSET+msk_offset);
-}
-
-static void mask_and_ack_intc2(unsigned int irq)
-{
-        disable_intc2_irq(irq);
-}
-
-static void end_intc2_irq(unsigned int irq)
-{
-        if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS)))
-                enable_intc2_irq(irq);
-
-#ifdef CONFIG_CPU_SUBTYPE_ST40
-        if (intc2_data[irq - INTC2_FIRST_IRQ].clear_irq)
-                intc2_data[irq - INTC2_FIRST_IRQ].clear_irq (irq);
-#endif
-}
-
-/*
- * Setup an INTC2 style interrupt.
- * NOTE: Unlike IPR interrupts, parameters are not shifted by this code,
- * allowing the use of the numbers straight out of the datasheet.
- * For example:
- *    PIO1 which is INTPRI00[19,16] and INTMSK00[13]
- * would be:               ^     ^             ^  ^
- *                         |     |             |  |
- *    make_intc2_irq(84,   0,   16,            0, 13);
- */
-void make_intc2_irq(unsigned int irq,
-                    unsigned int ipr_offset, unsigned int ipr_shift,
-                    unsigned int msk_offset, unsigned int msk_shift,
-                    unsigned int priority)
-{
-        int irq_offset = irq - INTC2_FIRST_IRQ;
-        unsigned int flags;
-        unsigned long ipr;
-
-        if((irq_offset<0) || (irq_offset>=NR_INTC2_IRQS))
-                return;
-
-        disable_irq_nosync(irq);
-
-        /* Fill the data we need */
-        intc2_data[irq_offset].msk_offset = msk_offset;
-        intc2_data[irq_offset].msk_shift  = msk_shift;
-#ifdef CONFIG_CPU_SUBTYPE_ST40
-        intc2_data[irq_offset].clear_irq = NULL;
-#endif
-                
-        /* Set the priority level */
-        local_irq_save(flags);
-
-        ipr=ctrl_inl(INTC2_BASE+INTC2_INTPRI_OFFSET+ipr_offset);
-        ipr&=~(0xf<<ipr_shift);
-        ipr|=(priority)<<ipr_shift;
-        ctrl_outl(ipr, INTC2_BASE+INTC2_INTPRI_OFFSET+ipr_offset);
-
-        local_irq_restore(flags);
-
-        irq_desc[irq].handler=&intc2_irq_type;
-
-        disable_intc2_irq(irq);
-}
-
-#ifdef CONFIG_CPU_SUBTYPE_ST40
-
-struct intc2_init {
-        unsigned short irq;
-        unsigned char ipr_offset, ipr_shift;
-        unsigned char msk_offset, msk_shift;
-};
-
-static struct intc2_init intc2_init_data[]  __initdata = {
-        {64,  0,  0, 0,  0},    /* PCI serr */
-        {65,  0,  4, 0,  1},    /* PCI err */
-        {66,  0,  4, 0,  2},    /* PCI ad */
-        {67,  0,  4, 0,  3},    /* PCI pwd down */
-        {72,  0,  8, 0,  5},    /* DMAC INT0 */
-        {73,  0,  8, 0,  6},    /* DMAC INT1 */
-        {74,  0,  8, 0,  7},    /* DMAC INT2 */
-        {75,  0,  8, 0,  8},    /* DMAC INT3 */
-        {76,  0,  8, 0,  9},    /* DMAC INT4 */
-        {78,  0,  8, 0, 11},    /* DMAC ERR */
-        {80,  0, 12, 0, 12},    /* PIO0 */
-        {84,  0, 16, 0, 13},    /* PIO1 */
-        {88,  0, 20, 0, 14},    /* PIO2 */
-        {112, 4,  0, 4,  0},    /* Mailbox */
-#ifdef CONFIG_CPU_SUBTYPE_ST40GX1
-        {116, 4,  4, 4,  4},    /* SSC0 */
-        {120, 4,  8, 4,  8},    /* IR Blaster */
-        {124, 4, 12, 4, 12},    /* USB host */
-        {128, 4, 16, 4, 16},    /* Video processor BLITTER */
-        {132, 4, 20, 4, 20},    /* UART0 */
-        {134, 4, 20, 4, 22},    /* UART2 */
-        {136, 4, 24, 4, 24},    /* IO_PIO0 */
-        {140, 4, 28, 4, 28},    /* EMPI */
-        {144, 8,  0, 8,  0},    /* MAFE */
-        {148, 8,  4, 8,  4},    /* PWM */
-        {152, 8,  8, 8,  8},    /* SSC1 */
-        {156, 8, 12, 8, 12},    /* IO_PIO1 */
-        {160, 8, 16, 8, 16},    /* USB target */
-        {164, 8, 20, 8, 20},    /* UART1 */
-        {168, 8, 24, 8, 24},    /* Teletext */
-        {172, 8, 28, 8, 28},    /* VideoSync VTG */
-        {173, 8, 28, 8, 29},    /* VideoSync DVP0 */
-        {174, 8, 28, 8, 30},    /* VideoSync DVP1 */
-#endif
-};
-
-void __init init_IRQ_intc2(void)
-{
-        struct intc2_init *p;
-
-        printk(KERN_ALERT "init_IRQ_intc2\n");
-
-        for (p = intc2_init_data;
-             p<intc2_init_data+ARRAY_SIZE(intc2_init_data);
-             p++) {
-                make_intc2_irq(p->irq, p->ipr_offset, p->ipr_shift,
-                               p-> msk_offset, p->msk_shift, 13);
-        }
-}
-
-/* Adds a termination callback to the interrupt */
-void intc2_add_clear_irq(int irq, int (*fn)(int))
-{
-        if (irq < INTC2_FIRST_IRQ)
-                return;
-
-        intc2_data[irq - INTC2_FIRST_IRQ].clear_irq = fn;
-}
-
-#endif /* CONFIG_CPU_SUBTYPE_ST40 */
diff --git a/arch/sh/kernel/io.c b/arch/sh/kernel/io.c
index d9932f25993b..71c9fde2fd90 100644
--- a/arch/sh/kernel/io.c
+++ b/arch/sh/kernel/io.c
@@ -2,58 +2,73 @@
  * linux/arch/sh/kernel/io.c
  *
  * Copyright (C) 2000  Stuart Menefy
+ * Copyright (C) 2005  Paul Mundt
  *
  * Provide real functions which expand to whatever the header file defined.
  * Also definitions of machine independent IO functions.
+ *
+ * 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.
  */
-
-#include <asm/io.h>
 #include <linux/module.h>
+#include <asm/machvec.h>
+#include <asm/io.h>
 
 /*
  * Copy data from IO memory space to "real" memory space.
  * This needs to be optimized.
  */
-void  memcpy_fromio(void * to, unsigned long from, unsigned long count)
+void memcpy_fromio(void *to, volatile void __iomem *from, unsigned long count)
 {
         char *p = to;
         while (count) {
                 count--;
-                *p = readb(from);
+                *p = readb((void __iomem *)from);
                 p++;
                 from++;
         }
 }
- 
+EXPORT_SYMBOL(memcpy_fromio);
+
 /*
  * Copy data from "real" memory space to IO memory space.
  * This needs to be optimized.
  */
-void  memcpy_toio(unsigned long to, const void * from, unsigned long count)
+void memcpy_toio(volatile void __iomem *to, const void *from, unsigned long count)
 {
         const char *p = from;
         while (count) {
                 count--;
-                writeb(*p, to);
+                writeb(*p, (void __iomem *)to);
                 p++;
                 to++;
         }
 }
- 
+EXPORT_SYMBOL(memcpy_toio);
+
 /*
  * "memset" on IO memory space.
  * This needs to be optimized.
  */
-void  memset_io(unsigned long dst, int c, unsigned long count)
+void memset_io(volatile void __iomem *dst, int c, unsigned long count)
 {
         while (count) {
                 count--;
-                writeb(c, dst);
+                writeb(c, (void __iomem *)dst);
                 dst++;
         }
 }
-
-EXPORT_SYMBOL(memcpy_fromio);
-EXPORT_SYMBOL(memcpy_toio);
 EXPORT_SYMBOL(memset_io);
 
+void __iomem *ioport_map(unsigned long port, unsigned int nr)
+{
+        return sh_mv.mv_ioport_map(port, nr);
+}
+EXPORT_SYMBOL(ioport_map);
+
+void ioport_unmap(void __iomem *addr)
+{
+        sh_mv.mv_ioport_unmap(addr);
+}
+EXPORT_SYMBOL(ioport_unmap);
diff --git a/arch/sh/kernel/io_generic.c b/arch/sh/kernel/io_generic.c
index a911b0149d1f..28ec7487de8c 100644
--- a/arch/sh/kernel/io_generic.c
+++ b/arch/sh/kernel/io_generic.c
@@ -3,6 +3,7 @@
  * linux/arch/sh/kernel/io_generic.c
  *
  * Copyright (C) 2000  Niibe Yutaka
+ * Copyright (C) 2005  Paul Mundt
  *
  * Generic I/O routine. These can be used where a machine specific version
  * is not required.
@@ -10,21 +11,20 @@
  * 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.
- *
  */
-
+#include <linux/module.h>
 #include <asm/io.h>
 #include <asm/machvec.h>
-#include <linux/module.h>
 
-#if defined(CONFIG_CPU_SH3)
+#ifdef CONFIG_CPU_SH3
+/* SH3 has a PCMCIA bug that needs a dummy read from area 6 for a
+ * workaround. */
 /* I'm not sure SH7709 has this kind of bug */
-#define SH3_PCMCIA_BUG_WORKAROUND 1
-#define DUMMY_READ_AREA6          0xba000000
+#define dummy_read()    ctrl_inb(0xba000000)
+#else
+#define dummy_read()
 #endif
 
-#define PORT2ADDR(x) (sh_mv.mv_isa_port2addr(x))
-
 unsigned long generic_io_base;
 
 static inline void delay(void)
@@ -32,40 +32,40 @@ static inline void delay(void)
         ctrl_inw(0xa0000000);
 }
 
-unsigned char generic_inb(unsigned long port)
+u8 generic_inb(unsigned long port)
 {
-        return *(volatile unsigned char*)PORT2ADDR(port);
+        return ctrl_inb((unsigned long __force)ioport_map(port, 1));
 }
 
-unsigned short generic_inw(unsigned long port)
+u16 generic_inw(unsigned long port)
 {
-        return *(volatile unsigned short*)PORT2ADDR(port);
+        return ctrl_inw((unsigned long __force)ioport_map(port, 2));
 }
 
-unsigned int generic_inl(unsigned long port)
+u32 generic_inl(unsigned long port)
 {
-        return *(volatile unsigned long*)PORT2ADDR(port);
+        return ctrl_inl((unsigned long __force)ioport_map(port, 4));
 }
 
-unsigned char generic_inb_p(unsigned long port)
+u8 generic_inb_p(unsigned long port)
 {
-        unsigned long v = *(volatile unsigned char*)PORT2ADDR(port);
+        unsigned long v = generic_inb(port);
 
         delay();
         return v;
 }
 
-unsigned short generic_inw_p(unsigned long port)
+u16 generic_inw_p(unsigned long port)
 {
-        unsigned long v = *(volatile unsigned short*)PORT2ADDR(port);
+        unsigned long v = generic_inw(port);
 
         delay();
         return v;
 }
 
-unsigned int generic_inl_p(unsigned long port)
+u32 generic_inl_p(unsigned long port)
 {
-        unsigned long v = *(volatile unsigned long*)PORT2ADDR(port);
+        unsigned long v = generic_inl(port);
 
         delay();
         return v;
@@ -77,75 +77,70 @@ unsigned int generic_inl_p(unsigned long port)
  * convert the port address to real address once.
  */
 
-void generic_insb(unsigned long port, void *buffer, unsigned long count)
+void generic_insb(unsigned long port, void *dst, unsigned long count)
 {
-        volatile unsigned char *port_addr;
-        unsigned char *buf=buffer;
-
-        port_addr = (volatile unsigned char *)PORT2ADDR(port);
+        volatile u8 *port_addr;
+        u8 *buf = dst;
 
-        while(count--)
-            *buf++ = *port_addr;
+        port_addr = (volatile u8 *)ioport_map(port, 1);
+        while (count--)
+                *buf++ = *port_addr;
 }
 
-void generic_insw(unsigned long port, void *buffer, unsigned long count)
+void generic_insw(unsigned long port, void *dst, unsigned long count)
 {
-        volatile unsigned short *port_addr;
-        unsigned short *buf=buffer;
+        volatile u16 *port_addr;
+        u16 *buf = dst;
 
-        port_addr = (volatile unsigned short *)PORT2ADDR(port);
+        port_addr = (volatile u16 *)ioport_map(port, 2);
+        while (count--)
+                *buf++ = *port_addr;
 
-        while(count--)
-            *buf++ = *port_addr;
-#ifdef SH3_PCMCIA_BUG_WORKAROUND
-        ctrl_inb (DUMMY_READ_AREA6);
-#endif
+        dummy_read();
 }
 
-void generic_insl(unsigned long port, void *buffer, unsigned long count)
+void generic_insl(unsigned long port, void *dst, unsigned long count)
 {
-        volatile unsigned long *port_addr;
-        unsigned long *buf=buffer;
+        volatile u32 *port_addr;
+        u32 *buf = dst;
 
-        port_addr = (volatile unsigned long *)PORT2ADDR(port);
+        port_addr = (volatile u32 *)ioport_map(port, 4);
+        while (count--)
+                *buf++ = *port_addr;
 
-        while(count--)
-            *buf++ = *port_addr;
-#ifdef SH3_PCMCIA_BUG_WORKAROUND
-        ctrl_inb (DUMMY_READ_AREA6);
-#endif
+        dummy_read();
 }
 
-void generic_outb(unsigned char b, unsigned long port)
+void generic_outb(u8 b, unsigned long port)
 {
-        *(volatile unsigned char*)PORT2ADDR(port) = b;
+        ctrl_outb(b, (unsigned long __force)ioport_map(port, 1));
 }
 
-void generic_outw(unsigned short b, unsigned long port)
+void generic_outw(u16 b, unsigned long port)
 {
-        *(volatile unsigned short*)PORT2ADDR(port) = b;
+        ctrl_outw(b, (unsigned long __force)ioport_map(port, 2));
 }
 
-void generic_outl(unsigned int b, unsigned long port)
+void generic_outl(u32 b, unsigned long port)
 {
-        *(volatile unsigned long*)PORT2ADDR(port) = b;
+        ctrl_outl(b, (unsigned long __force)ioport_map(port, 4));
 }
 
-void generic_outb_p(unsigned char b, unsigned long port)
+void generic_outb_p(u8 b, unsigned long port)
 {
-        *(volatile unsigned char*)PORT2ADDR(port) = b;
+        generic_outb(b, port);
         delay();
 }
 
-void generic_outw_p(unsigned short b, unsigned long port)
+void generic_outw_p(u16 b, unsigned long port)
 {
-        *(volatile unsigned short*)PORT2ADDR(port) = b;
+        generic_outw(b, port);
         delay();
 }
 
-void generic_outl_p(unsigned int b, unsigned long port)
+void generic_outl_p(u32 b, unsigned long port)
 {
-        *(volatile unsigned long*)PORT2ADDR(port) = b;
+        generic_outl(b, port);
         delay();
 }
 
@@ -154,90 +149,77 @@ void generic_outl_p(unsigned int b, unsigned long port)
  * address. However as the port address doesn't change we only need to
  * convert the port address to real address once.
  */
-
-void generic_outsb(unsigned long port, const void *buffer, unsigned long count)
+void generic_outsb(unsigned long port, const void *src, unsigned long count)
 {
-        volatile unsigned char *port_addr;
-        const unsigned char *buf=buffer;
+        volatile u8 *port_addr;
+        const u8 *buf = src;
 
-        port_addr = (volatile unsigned char *)PORT2ADDR(port);
+        port_addr = (volatile u8 __force *)ioport_map(port, 1);
 
-        while(count--)
-            *port_addr = *buf++;
+        while (count--)
+                *port_addr = *buf++;
 }
 
-void generic_outsw(unsigned long port, const void *buffer, unsigned long count)
+void generic_outsw(unsigned long port, const void *src, unsigned long count)
 {
-        volatile unsigned short *port_addr;
-        const unsigned short *buf=buffer;
+        volatile u16 *port_addr;
+        const u16 *buf = src;
 
-        port_addr = (volatile unsigned short *)PORT2ADDR(port);
+        port_addr = (volatile u16 __force *)ioport_map(port, 2);
 
-        while(count--)
-            *port_addr = *buf++;
+        while (count--)
+                *port_addr = *buf++;
 
-#ifdef SH3_PCMCIA_BUG_WORKAROUND
-        ctrl_inb (DUMMY_READ_AREA6);
-#endif
+        dummy_read();
 }
 
-void generic_outsl(unsigned long port, const void *buffer, unsigned long count)
+void generic_outsl(unsigned long port, const void *src, unsigned long count)
 {
-        volatile unsigned long *port_addr;
-        const unsigned long *buf=buffer;
+        volatile u32 *port_addr;
+        const u32 *buf = src;
 
-        port_addr = (volatile unsigned long *)PORT2ADDR(port);
+        port_addr = (volatile u32 __force *)ioport_map(port, 4);
+        while (count--)
+                *port_addr = *buf++;
 
-        while(count--)
-            *port_addr = *buf++;
-
-#ifdef SH3_PCMCIA_BUG_WORKAROUND
-        ctrl_inb (DUMMY_READ_AREA6);
-#endif
-}
-
-unsigned char generic_readb(unsigned long addr)
-{
-        return *(volatile unsigned char*)addr;
+        dummy_read();
 }
 
-unsigned short generic_readw(unsigned long addr)
+u8 generic_readb(void __iomem *addr)
 {
-        return *(volatile unsigned short*)addr;
+        return ctrl_inb((unsigned long __force)addr);
 }
 
-unsigned int generic_readl(unsigned long addr)
+u16 generic_readw(void __iomem *addr)
 {
-        return *(volatile unsigned long*)addr;
+        return ctrl_inw((unsigned long __force)addr);
 }
 
-void generic_writeb(unsigned char b, unsigned long addr)
+u32 generic_readl(void __iomem *addr)
 {
-        *(volatile unsigned char*)addr = b;
+        return ctrl_inl((unsigned long __force)addr);
 }
 
-void generic_writew(unsigned short b, unsigned long addr)
+void generic_writeb(u8 b, void __iomem *addr)
 {
-        *(volatile unsigned short*)addr = b;
+        ctrl_outb(b, (unsigned long __force)addr);
 }
 
-void generic_writel(unsigned int b, unsigned long addr)
+void generic_writew(u16 b, void __iomem *addr)
 {
-        *(volatile unsigned long*)addr = b;
+        ctrl_outw(b, (unsigned long __force)addr);
 }
 
-void * generic_ioremap(unsigned long offset, unsigned long size)
+void generic_writel(u32 b, void __iomem *addr)
 {
-        return (void *) P2SEGADDR(offset);
+        ctrl_outl(b, (unsigned long __force)addr);
 }
-EXPORT_SYMBOL(generic_ioremap);
 
-void generic_iounmap(void *addr)
+void __iomem *generic_ioport_map(unsigned long addr, unsigned int size)
 {
+        return (void __iomem *)(addr + generic_io_base);
 }
-EXPORT_SYMBOL(generic_iounmap);
 
-unsigned long generic_isa_port2addr(unsigned long offset)
+void generic_ioport_unmap(void __iomem *addr)
 {
-        return offset + generic_io_base;
 }
diff --git a/arch/sh/kernel/irq.c b/arch/sh/kernel/irq.c
index 54c171225b78..6883c00728cb 100644
--- a/arch/sh/kernel/irq.c
+++ b/arch/sh/kernel/irq.c
@@ -8,38 +8,13 @@
  * SuperH version:  Copyright (C) 1999  Niibe Yutaka
  */
 
-/*
- * IRQs are in fact implemented a bit like signal handlers for the kernel.
- * Naturally it's not a 1:1 relation, but there are similarities.
- */
-
-#include <linux/config.h>
-#include <linux/module.h>
-#include <linux/ptrace.h>
-#include <linux/errno.h>
-#include <linux/kernel_stat.h>
-#include <linux/signal.h>
-#include <linux/sched.h>
-#include <linux/ioport.h>
+#include <linux/irq.h>
 #include <linux/interrupt.h>
-#include <linux/timex.h>
-#include <linux/mm.h>
-#include <linux/slab.h>
-#include <linux/random.h>
-#include <linux/smp.h>
-#include <linux/smp_lock.h>
-#include <linux/init.h>
+#include <linux/kernel_stat.h>
 #include <linux/seq_file.h>
-#include <linux/kallsyms.h>
-#include <linux/bitops.h>
-
-#include <asm/system.h>
-#include <asm/io.h>
-#include <asm/pgalloc.h>
-#include <asm/delay.h>
 #include <asm/irq.h>
-#include <linux/irq.h>
-
+#include <asm/processor.h>
+#include <asm/cpu/mmu_context.h>
 
 /*
  * 'what should we do if we get a hw irq event on an illegal vector'.
@@ -66,7 +41,7 @@ int show_interrupts(struct seq_file *p, void *v)
                 seq_putc(p, '\n');
         }
 
-        if (i < ACTUAL_NR_IRQS) {
+        if (i < NR_IRQS) {
                 spin_lock_irqsave(&irq_desc[i].lock, flags);
                 action = irq_desc[i].action;
                 if (!action)
@@ -86,19 +61,32 @@ unlock:
 }
 #endif
 
+
 asmlinkage int do_IRQ(unsigned long r4, unsigned long r5,
                       unsigned long r6, unsigned long r7,
                       struct pt_regs regs)
-{       
-        int irq;
+{
+        int irq = r4;
 
         irq_enter();
-        asm volatile("stc       r2_bank, %0\n\t"
-                     "shlr2     %0\n\t"
-                     "shlr2     %0\n\t"
-                     "shlr      %0\n\t"
-                     "add       #-16, %0\n\t"
-                     :"=z" (irq));
+
+#ifdef CONFIG_CPU_HAS_INTEVT
+        __asm__ __volatile__ (
+#ifdef CONFIG_CPU_HAS_SR_RB
+                "stc    r2_bank, %0\n\t"
+#else
+                "mov.l  @%1, %0\n\t"
+#endif
+                "shlr2  %0\n\t"
+                "shlr2  %0\n\t"
+                "shlr   %0\n\t"
+                "add    #-16, %0\n\t"
+                : "=z" (irq), "=r" (r4)
+                : "1" (INTEVT)
+                : "memory"
+        );
+#endif
+
         irq = irq_demux(irq);
         __do_IRQ(irq, &regs);
         irq_exit();
diff --git a/arch/sh/kernel/machine_kexec.c b/arch/sh/kernel/machine_kexec.c
new file mode 100644
index 000000000000..43546525f28f
--- /dev/null
+++ b/arch/sh/kernel/machine_kexec.c
@@ -0,0 +1,112 @@
+/*
+ * machine_kexec.c - handle transition of Linux booting another kernel
+ * Copyright (C) 2002-2003 Eric Biederman  <ebiederm@xmission.com>
+ *
+ * GameCube/ppc32 port Copyright (C) 2004 Albert Herranz
+ * LANDISK/sh4 supported by kogiidena
+ *
+ * This source code is licensed under the GNU General Public License,
+ * Version 2.  See the file COPYING for more details.
+ */
+
+#include <linux/mm.h>
+#include <linux/kexec.h>
+#include <linux/delay.h>
+#include <linux/reboot.h>
+#include <asm/pgtable.h>
+#include <asm/pgalloc.h>
+#include <asm/mmu_context.h>
+#include <asm/io.h>
+#include <asm/cacheflush.h>
+
+typedef NORET_TYPE void (*relocate_new_kernel_t)(
+                                unsigned long indirection_page,
+                                unsigned long reboot_code_buffer,
+                                unsigned long start_address,
+                                unsigned long vbr_reg) ATTRIB_NORET;
+
+const extern unsigned char relocate_new_kernel[];
+const extern unsigned int relocate_new_kernel_size;
+extern void *gdb_vbr_vector;
+
+/*
+ * Provide a dummy crash_notes definition while crash dump arrives to ppc.
+ * This prevents breakage of crash_notes attribute in kernel/ksysfs.c.
+ */
+void *crash_notes = NULL;
+
+void machine_shutdown(void)
+{
+}
+
+void machine_crash_shutdown(struct pt_regs *regs)
+{
+}
+
+/*
+ * Do what every setup is needed on image and the
+ * reboot code buffer to allow us to avoid allocations
+ * later.
+ */
+int machine_kexec_prepare(struct kimage *image)
+{
+        return 0;
+}
+
+void machine_kexec_cleanup(struct kimage *image)
+{
+}
+
+static void kexec_info(struct kimage *image)
+{
+        int i;
+        printk("kexec information\n");
+        for (i = 0; i < image->nr_segments; i++) {
+                printk("  segment[%d]: 0x%08x - 0x%08x (0x%08x)\n",
+                       i,
+                       (unsigned int)image->segment[i].mem,
+                       (unsigned int)image->segment[i].mem + image->segment[i].memsz,
+                       (unsigned int)image->segment[i].memsz);
+        }
+        printk("  start     : 0x%08x\n\n", (unsigned int)image->start);
+}
+
+
+/*
+ * Do not allocate memory (or fail in any way) in machine_kexec().
+ * We are past the point of no return, committed to rebooting now.
+ */
+NORET_TYPE void machine_kexec(struct kimage *image)
+{
+
+        unsigned long page_list;
+        unsigned long reboot_code_buffer;
+        unsigned long vbr_reg;
+        relocate_new_kernel_t rnk;
+
+#if defined(CONFIG_SH_STANDARD_BIOS)
+        vbr_reg = ((unsigned long )gdb_vbr_vector) - 0x100;
+#else
+        vbr_reg = 0x80000000;  // dummy
+#endif
+        /* Interrupts aren't acceptable while we reboot */
+        local_irq_disable();
+
+        page_list = image->head;
+
+        /* we need both effective and real address here */
+        reboot_code_buffer =
+                        (unsigned long)page_address(image->control_code_page);
+
+        /* copy our kernel relocation code to the control code page */
+        memcpy((void *)reboot_code_buffer, relocate_new_kernel,
+                                                relocate_new_kernel_size);
+
+        kexec_info(image);
+        flush_cache_all();
+
+        /* now call it */
+        rnk = (relocate_new_kernel_t) reboot_code_buffer;
+        (*rnk)(page_list, reboot_code_buffer, image->start, vbr_reg);
+}
+
diff --git a/arch/sh/kernel/process.c b/arch/sh/kernel/process.c
index aac15e42d03b..a4dc2b532e10 100644
--- a/arch/sh/kernel/process.c
+++ b/arch/sh/kernel/process.c
@@ -71,6 +71,16 @@ void cpu_idle(void)
 
 void machine_restart(char * __unused)
 {
+
+#ifdef CONFIG_KEXEC
+        struct kimage *image;
+        image = xchg(&kexec_image, 0);
+        if (image) {
+                machine_shutdown();
+                machine_kexec(image);
+        }
+#endif
+
         /* SR.BL=1 and invoke address error to let CPU reset (manual reset) */
         asm volatile("ldc %0, sr\n\t"
                      "mov.l @%1, %0" : : "r" (0x10000000), "r" (0x80000001));
diff --git a/arch/sh/kernel/relocate_kernel.S b/arch/sh/kernel/relocate_kernel.S
new file mode 100644
index 000000000000..b0695cffec6e
--- /dev/null
+++ b/arch/sh/kernel/relocate_kernel.S
@@ -0,0 +1,102 @@
+/*
+ * relocate_kernel.S - put the kernel image in place to boot
+ * 2005.9.17 kogiidena@eggplant.ddo.jp
+ *
+ * LANDISK/sh4 is supported. Maybe, SH archtecture works well.
+ *
+ * This source code is licensed under the GNU General Public License,
+ * Version 2.  See the file COPYING for more details.
+ */
+
+#include <linux/config.h>
+#include <linux/linkage.h>
+
+#define PAGE_SIZE      4096 /* must be same value as in <asm/page.h> */
+
+
+                .globl relocate_new_kernel
+relocate_new_kernel:
+        /* r4 = indirection_page   */
+        /* r5 = reboot_code_buffer */
+        /* r6 = start_address      */
+        /* r7 = vbr_reg            */
+
+        mov.l   10f,r8    /* 4096 */
+        mov.l   11f,r9    /* 0xa0000000 */
+
+        /*  stack setting */
+        add     r8,r5
+        mov     r5,r15
+
+        bra     1f
+        mov     r4,r0     /* cmd = indirection_page */
+0:
+        mov.l   @r4+,r0   /* cmd = *ind++ */
+
+1:      /* addr = (cmd | 0xa0000000) & 0xfffffff0 */
+        mov     r0,r2
+        or      r9,r2
+        mov     #-16,r1
+        and     r1,r2
+
+        /* if(cmd & IND_DESTINATION) dst = addr  */
+        tst     #1,r0
+        bt      2f
+        bra     0b
+        mov     r2,r5
+
+2:      /* else if(cmd & IND_INDIRECTION) ind = addr  */
+        tst     #2,r0
+        bt      3f
+        bra     0b
+        mov     r2,r4
+
+3:      /* else if(cmd & IND_DONE) goto 6  */
+        tst     #4,r0
+        bt      4f
+        bra     6f
+        nop
+
+4:      /* else if(cmd & IND_SOURCE) memcpy(dst,addr,PAGE_SIZE) */
+        tst     #8,r0
+        bt      0b
+
+        mov     r8,r3
+        shlr2   r3
+        shlr2   r3
+5:
+        dt      r3
+        mov.l   @r2+,r1   /*  16n+0 */
+        mov.l   r1,@r5
+        add     #4,r5
+        mov.l   @r2+,r1   /*  16n+4 */
+        mov.l   r1,@r5
+        add     #4,r5
+        mov.l   @r2+,r1   /*  16n+8 */
+        mov.l   r1,@r5
+        add     #4,r5
+        mov.l   @r2+,r1   /*  16n+12 */
+        mov.l   r1,@r5
+        add     #4,r5
+        bf      5b
+
+        bra     0b
+        nop
+6:
+#ifdef CONFIG_SH_STANDARD_BIOS
+        ldc   r7, vbr
+#endif
+        jmp @r6
+        nop
+
+        .align 2
+10:
+        .long   PAGE_SIZE
+11:
+        .long   0xa0000000
+
+relocate_new_kernel_end:
+
+        .globl relocate_new_kernel_size
+relocate_new_kernel_size:
+        .long relocate_new_kernel_end - relocate_new_kernel
diff --git a/arch/sh/kernel/time.c b/arch/sh/kernel/time.c
index 671b876416bf..314a275c04e0 100644
--- a/arch/sh/kernel/time.c
+++ b/arch/sh/kernel/time.c
@@ -3,7 +3,7 @@
  *
  *  Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
  *  Copyright (C) 2000  Philipp Rumpf <prumpf@tux.org>
- *  Copyright (C) 2002, 2003, 2004  Paul Mundt
+ *  Copyright (C) 2002, 2003, 2004, 2005  Paul Mundt
  *  Copyright (C) 2002  M. R. Brown  <mrbrown@linux-sh.org>
  *
  *  Some code taken from i386 version.
@@ -11,50 +11,21 @@
  */
 
 #include <linux/config.h>
-#include <linux/errno.h>
-#include <linux/module.h>
-#include <linux/sched.h>
 #include <linux/kernel.h>
-#include <linux/param.h>
-#include <linux/string.h>
-#include <linux/mm.h>
-#include <linux/interrupt.h>
-#include <linux/time.h>
-#include <linux/delay.h>
+#include <linux/module.h>
 #include <linux/init.h>
-#include <linux/smp.h>
 #include <linux/profile.h>
-
-#include <asm/processor.h>
-#include <asm/uaccess.h>
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/delay.h>
-#include <asm/machvec.h>
+#include <asm/clock.h>
 #include <asm/rtc.h>
-#include <asm/freq.h>
-#include <asm/cpu/timer.h>
-#ifdef CONFIG_SH_KGDB
+#include <asm/timer.h>
 #include <asm/kgdb.h>
-#endif
-
-#include <linux/timex.h>
-#include <linux/irq.h>
-
-#define TMU_TOCR_INIT   0x00
-#define TMU0_TCR_INIT   0x0020
-#define TMU_TSTR_INIT   1
-
-#define TMU0_TCR_CALIB  0x0000
-
-#ifdef CONFIG_CPU_SUBTYPE_ST40STB1
-#define CLOCKGEN_MEMCLKCR 0xbb040038
-#define MEMCLKCR_RATIO_MASK 0x7
-#endif /* CONFIG_CPU_SUBTYPE_ST40STB1 */
 
 extern unsigned long wall_jiffies;
-#define TICK_SIZE (tick_nsec / 1000)
-DEFINE_SPINLOCK(tmu0_lock);
+struct sys_timer *sys_timer;
+
+/* Move this somewhere more sensible.. */
+DEFINE_SPINLOCK(rtc_lock);
+EXPORT_SYMBOL(rtc_lock);
 
 /* XXX: Can we initialize this in a routine somewhere?  Dreamcast doesn't want
  * these routines anywhere... */
@@ -66,98 +37,14 @@ void (*rtc_get_time)(struct timespec *);
 int (*rtc_set_time)(const time_t);
 #endif
 
-#if defined(CONFIG_CPU_SUBTYPE_SH7300)
-static int md_table[] = { 1, 2, 3, 4, 6, 8, 12 };
-#endif
-#if defined(CONFIG_CPU_SH3)
-static int stc_multipliers[] = { 1, 2, 3, 4, 6, 1, 1, 1 };
-static int stc_values[]      = { 0, 1, 4, 2, 5, 0, 0, 0 };
-#define bfc_divisors stc_multipliers
-#define bfc_values stc_values
-static int ifc_divisors[]    = { 1, 2, 3, 4, 1, 1, 1, 1 };
-static int ifc_values[]      = { 0, 1, 4, 2, 0, 0, 0, 0 };
-static int pfc_divisors[]    = { 1, 2, 3, 4, 6, 1, 1, 1 };
-static int pfc_values[]      = { 0, 1, 4, 2, 5, 0, 0, 0 };
-#elif defined(CONFIG_CPU_SH4)
-#if defined(CONFIG_CPU_SUBTYPE_SH73180)
-static int ifc_divisors[] = { 1, 2, 3, 4, 6, 8, 12, 16 };
-static int ifc_values[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
-#define bfc_divisors ifc_divisors       /* Same */
-#define bfc_values ifc_values
-#define pfc_divisors ifc_divisors       /* Same */
-#define pfc_values ifc_values
-#else
-static int ifc_divisors[] = { 1, 2, 3, 4, 6, 8, 1, 1 };
-static int ifc_values[]   = { 0, 1, 2, 3, 0, 4, 0, 5 };
-#define bfc_divisors ifc_divisors       /* Same */
-#define bfc_values ifc_values
-static int pfc_divisors[] = { 2, 3, 4, 6, 8, 2, 2, 2 };
-static int pfc_values[]   = { 0, 0, 1, 2, 0, 3, 0, 4 };
-#endif
-#else
-#error "Unknown ifc/bfc/pfc/stc values for this processor"
-#endif
-
 /*
  * Scheduler clock - returns current time in nanosec units.
  */
-unsigned long long sched_clock(void)
+unsigned long long __attribute__ ((weak)) sched_clock(void)
 {
         return (unsigned long long)jiffies * (1000000000 / HZ);
 }
 
-static unsigned long do_gettimeoffset(void)
-{
-        int count;
-        unsigned long flags;
-
-        static int count_p = 0x7fffffff;    /* for the first call after boot */
-        static unsigned long jiffies_p = 0;
-
-        /*
-         * cache volatile jiffies temporarily; we have IRQs turned off.
-         */
-        unsigned long jiffies_t;
-
-        spin_lock_irqsave(&tmu0_lock, flags);
-        /* timer count may underflow right here */
-        count = ctrl_inl(TMU0_TCNT);    /* read the latched count */
-
-        jiffies_t = jiffies;
-
-        /*
-         * avoiding timer inconsistencies (they are rare, but they happen)...
-         * there is one kind of problem that must be avoided here:
-         *  1. the timer counter underflows
-         */
-
-        if( jiffies_t == jiffies_p ) {
-                if( count > count_p ) {
-                        /* the nutcase */
-
-                        if(ctrl_inw(TMU0_TCR) & 0x100) { /* Check UNF bit */
-                                /*
-                                 * We cannot detect lost timer interrupts ...
-                                 * well, that's why we call them lost, don't we? :)
-                                 * [hmm, on the Pentium and Alpha we can ... sort of]
-                                 */
-                                count -= LATCH;
-                        } else {
-                                printk("do_slow_gettimeoffset(): hardware timer problem?\n");
-                        }
-                }
-        } else
-                jiffies_p = jiffies_t;
-
-        count_p = count;
-        spin_unlock_irqrestore(&tmu0_lock, flags);
-
-        count = ((LATCH-1) - count) * TICK_SIZE;
-        count = (count + LATCH/2) / LATCH;
-
-        return count;
-}
-
 void do_gettimeofday(struct timeval *tv)
 {
         unsigned long seq;
@@ -166,7 +53,7 @@ void do_gettimeofday(struct timeval *tv)
 
         do {
                 seq = read_seqbegin(&xtime_lock);
-                usec = do_gettimeoffset();
+                usec = get_timer_offset();
 
                 lost = jiffies - wall_jiffies;
                 if (lost)
@@ -202,7 +89,7 @@ int do_settimeofday(struct timespec *tv)
          * wall time.  Discover what correction gettimeofday() would have
          * made, and then undo it!
          */
-        nsec -= 1000 * (do_gettimeoffset() +
+        nsec -= 1000 * (get_timer_offset() +
                                 (jiffies - wall_jiffies) * (1000000 / HZ));
 
         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
@@ -224,10 +111,10 @@ EXPORT_SYMBOL(do_settimeofday);
 static long last_rtc_update;
 
 /*
- * timer_interrupt() needs to keep up the real-time clock,
+ * handle_timer_tick() needs to keep up the real-time clock,
  * as well as call the "do_timer()" routine every clocktick
  */
-static inline void do_timer_interrupt(int irq, struct pt_regs *regs)
+void handle_timer_tick(struct pt_regs *regs)
 {
         do_timer(regs);
 #ifndef CONFIG_SMP
@@ -252,337 +139,35 @@ static inline void do_timer_interrupt(int irq, struct pt_regs *regs)
                 if (rtc_set_time(xtime.tv_sec) == 0)
                         last_rtc_update = xtime.tv_sec;
                 else
-                        last_rtc_update = xtime.tv_sec - 600; /* do it again in 60 s */
+                        /* do it again in 60s */
+                        last_rtc_update = xtime.tv_sec - 600;
         }
 }
 
-/*
- * This is the same as the above, except we _also_ save the current
- * Time Stamp Counter value at the time of the timer interrupt, so that
- * we later on can estimate the time of day more exactly.
- */
-static irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        unsigned long timer_status;
-
-        /* Clear UNF bit */
-        timer_status = ctrl_inw(TMU0_TCR);
-        timer_status &= ~0x100;
-        ctrl_outw(timer_status, TMU0_TCR);
-
-        /*
-         * Here we are in the timer irq handler. We just have irqs locally
-         * disabled but we don't know if the timer_bh is running on the other
-         * CPU. We need to avoid to SMP race with it. NOTE: we don' t need
-         * the irq version of write_lock because as just said we have irq
-         * locally disabled. -arca
-         */
-        write_seqlock(&xtime_lock);
-        do_timer_interrupt(irq, regs);
-        write_sequnlock(&xtime_lock);
-
-        return IRQ_HANDLED;
-}
-
-/*
- * Hah!  We'll see if this works (switching from usecs to nsecs).
- */
-static unsigned int __init get_timer_frequency(void)
-{
-        u32 freq;
-        struct timespec ts1, ts2;
-        unsigned long diff_nsec;
-        unsigned long factor;
-
-        /* Setup the timer:  We don't want to generate interrupts, just
-         * have it count down at its natural rate.
-         */
-        ctrl_outb(0, TMU_TSTR);
-#if !defined(CONFIG_CPU_SUBTYPE_SH7300)
-        ctrl_outb(TMU_TOCR_INIT, TMU_TOCR);
-#endif
-        ctrl_outw(TMU0_TCR_CALIB, TMU0_TCR);
-        ctrl_outl(0xffffffff, TMU0_TCOR);
-        ctrl_outl(0xffffffff, TMU0_TCNT);
-
-        rtc_get_time(&ts2);
-
-        do {
-                rtc_get_time(&ts1);
-        } while (ts1.tv_nsec == ts2.tv_nsec && ts1.tv_sec == ts2.tv_sec);
-
-        /* actually start the timer */
-        ctrl_outb(TMU_TSTR_INIT, TMU_TSTR);
-
-        do {
-                rtc_get_time(&ts2);
-        } while (ts1.tv_nsec == ts2.tv_nsec && ts1.tv_sec == ts2.tv_sec);
-
-        freq = 0xffffffff - ctrl_inl(TMU0_TCNT);
-        if (ts2.tv_nsec < ts1.tv_nsec) {
-                ts2.tv_nsec += 1000000000;
-                ts2.tv_sec--;
-        }
-
-        diff_nsec = (ts2.tv_sec - ts1.tv_sec) * 1000000000 + (ts2.tv_nsec - ts1.tv_nsec);
-
-        /* this should work well if the RTC has a precision of n Hz, where
-         * n is an integer.  I don't think we have to worry about the other
-         * cases. */
-        factor = (1000000000 + diff_nsec/2) / diff_nsec;
-
-        if (factor * diff_nsec > 1100000000 ||
-            factor * diff_nsec <  900000000)
-                panic("weird RTC (diff_nsec %ld)", diff_nsec);
-
-        return freq * factor;
-}
-
-void (*board_time_init)(void);
-void (*board_timer_setup)(struct irqaction *irq);
-
-static unsigned int sh_pclk_freq __initdata = CONFIG_SH_PCLK_FREQ;
-
-static int __init sh_pclk_setup(char *str)
-{
-        unsigned int freq;
-
-        if (get_option(&str, &freq))
-                sh_pclk_freq = freq;
-
-        return 1;
-}
-__setup("sh_pclk=", sh_pclk_setup);
-
-static struct irqaction irq0  = { timer_interrupt, SA_INTERRUPT, CPU_MASK_NONE, "timer", NULL, NULL};
-
-void get_current_frequency_divisors(unsigned int *ifc, unsigned int *bfc, unsigned int *pfc)
-{
-        unsigned int frqcr = ctrl_inw(FRQCR);
-
-#if defined(CONFIG_CPU_SH3)
-#if defined(CONFIG_CPU_SUBTYPE_SH7300)
-        *ifc = md_table[((frqcr & 0x0070) >> 4)];
-        *bfc = md_table[((frqcr & 0x0700) >> 8)];
-        *pfc = md_table[frqcr & 0x0007];
-#elif defined(CONFIG_CPU_SUBTYPE_SH7705)
-        *bfc = stc_multipliers[(frqcr & 0x0300) >> 8];
-        *ifc = ifc_divisors[(frqcr & 0x0030) >> 4];
-        *pfc = pfc_divisors[frqcr & 0x0003];
-#else
-        unsigned int tmp;
-
-        tmp  = (frqcr & 0x8000) >> 13;
-        tmp |= (frqcr & 0x0030) >>  4;
-        *bfc = stc_multipliers[tmp];
-        tmp  = (frqcr & 0x4000)  >> 12;
-        tmp |= (frqcr & 0x000c) >> 2;
-        *ifc = ifc_divisors[tmp];
-        tmp  = (frqcr & 0x2000) >> 11;
-        tmp |= frqcr & 0x0003;
-        *pfc = pfc_divisors[tmp];
-#endif
-#elif defined(CONFIG_CPU_SH4)
-#if defined(CONFIG_CPU_SUBTYPE_SH73180)
-        *ifc = ifc_divisors[(frqcr>> 20) & 0x0007];
-        *bfc = bfc_divisors[(frqcr>> 12) & 0x0007];
-        *pfc = pfc_divisors[frqcr & 0x0007];
-#else
-        *ifc = ifc_divisors[(frqcr >> 6) & 0x0007];
-        *bfc = bfc_divisors[(frqcr >> 3) & 0x0007];
-        *pfc = pfc_divisors[frqcr & 0x0007];
-#endif
-#endif
-}
-
-/*
- * This bit of ugliness builds up accessor routines to get at both
- * the divisors and the physical values.
- */
-#define _FREQ_TABLE(x) \
-        unsigned int get_##x##_divisor(unsigned int value)      \
-                { return x##_divisors[value]; }                 \
-                                                                \
-        unsigned int get_##x##_value(unsigned int divisor)      \
-                { return x##_values[(divisor - 1)]; }
-
-_FREQ_TABLE(ifc);
-_FREQ_TABLE(bfc);
-_FREQ_TABLE(pfc);
-
-#ifdef CONFIG_CPU_SUBTYPE_ST40STB1
-
-/*
- * The ST40 divisors are totally different so we set the cpu data
- * clocks using a different algorithm
- *
- * I've just plugged this from the 2.4 code
- *      - Alex Bennee <kernel-hacker@bennee.com>
- */
-#define CCN_PVR_CHIP_SHIFT 24
-#define CCN_PVR_CHIP_MASK  0xff
-#define CCN_PVR_CHIP_ST40STB1 0x4
-
-
-struct frqcr_data {
-        unsigned short frqcr;
-
-        struct {
-                unsigned char multiplier;
-                unsigned char divisor;
-        } factor[3];
-};
-
-static struct frqcr_data st40_frqcr_table[] = {
-        { 0x000, {{1,1}, {1,1}, {1,2}}},
-        { 0x002, {{1,1}, {1,1}, {1,4}}},
-        { 0x004, {{1,1}, {1,1}, {1,8}}},
-        { 0x008, {{1,1}, {1,2}, {1,2}}},
-        { 0x00A, {{1,1}, {1,2}, {1,4}}},
-        { 0x00C, {{1,1}, {1,2}, {1,8}}},
-        { 0x011, {{1,1}, {2,3}, {1,6}}},
-        { 0x013, {{1,1}, {2,3}, {1,3}}},
-        { 0x01A, {{1,1}, {1,2}, {1,4}}},
-        { 0x01C, {{1,1}, {1,2}, {1,8}}},
-        { 0x023, {{1,1}, {2,3}, {1,3}}},
-        { 0x02C, {{1,1}, {1,2}, {1,8}}},
-        { 0x048, {{1,2}, {1,2}, {1,4}}},
-        { 0x04A, {{1,2}, {1,2}, {1,6}}},
-        { 0x04C, {{1,2}, {1,2}, {1,8}}},
-        { 0x05A, {{1,2}, {1,3}, {1,6}}},
-        { 0x05C, {{1,2}, {1,3}, {1,6}}},
-        { 0x063, {{1,2}, {1,4}, {1,4}}},
-        { 0x06C, {{1,2}, {1,4}, {1,8}}},
-        { 0x091, {{1,3}, {1,3}, {1,6}}},
-        { 0x093, {{1,3}, {1,3}, {1,6}}},
-        { 0x0A3, {{1,3}, {1,6}, {1,6}}},
-        { 0x0DA, {{1,4}, {1,4}, {1,8}}},
-        { 0x0DC, {{1,4}, {1,4}, {1,8}}},
-        { 0x0EC, {{1,4}, {1,8}, {1,8}}},
-        { 0x123, {{1,4}, {1,4}, {1,8}}},
-        { 0x16C, {{1,4}, {1,8}, {1,8}}},
+static struct sysdev_class timer_sysclass = {
+        set_kset_name("timer"),
 };
 
-struct memclk_data {
-        unsigned char multiplier;
-        unsigned char divisor;
-};
-
-static struct memclk_data st40_memclk_table[8] = {
-        {1,1},  // 000
-        {1,2},  // 001
-        {1,3},  // 010
-        {2,3},  // 011
-        {1,4},  // 100
-        {1,6},  // 101
-        {1,8},  // 110
-        {1,8}   // 111
-};
-
-static void st40_specific_time_init(unsigned int module_clock, unsigned short frqcr)
+static int __init timer_init_sysfs(void)
 {
-        unsigned int cpu_clock, master_clock, bus_clock, memory_clock;
-        struct frqcr_data *d;
-        int a;
-        unsigned long memclkcr;
-        struct memclk_data *e;
+        int ret = sysdev_class_register(&timer_sysclass);
+        if (ret != 0)
+                return ret;
 
-        for (a = 0; a < ARRAY_SIZE(st40_frqcr_table); a++) {
-                d = &st40_frqcr_table[a];
-
-                if (d->frqcr == (frqcr & 0x1ff))
-                        break;
-        }
+        sys_timer->dev.cls = &timer_sysclass;
+        return sysdev_register(&sys_timer->dev);
+}
 
-        if (a == ARRAY_SIZE(st40_frqcr_table)) {
-                d = st40_frqcr_table;
+device_initcall(timer_init_sysfs);
 
-                printk("ERROR: Unrecognised FRQCR value (0x%x), "
-                       "using default multipliers\n", frqcr);
-        }
-
-        memclkcr = ctrl_inl(CLOCKGEN_MEMCLKCR);
-        e = &st40_memclk_table[memclkcr & MEMCLKCR_RATIO_MASK];
-
-        printk(KERN_INFO "Clock multipliers: CPU: %d/%d Bus: %d/%d "
-               "Mem: %d/%d Periph: %d/%d\n",
-               d->factor[0].multiplier, d->factor[0].divisor,
-               d->factor[1].multiplier, d->factor[1].divisor,
-               e->multiplier,           e->divisor,
-               d->factor[2].multiplier, d->factor[2].divisor);
-
-        master_clock = module_clock * d->factor[2].divisor
-                                    / d->factor[2].multiplier;
-        bus_clock    = master_clock * d->factor[1].multiplier
-                                    / d->factor[1].divisor;
-        memory_clock = master_clock * e->multiplier
-                                    / e->divisor;
-        cpu_clock    = master_clock * d->factor[0].multiplier
-                                    / d->factor[0].divisor;
-
-        current_cpu_data.cpu_clock    = cpu_clock;
-        current_cpu_data.master_clock = master_clock;
-        current_cpu_data.bus_clock    = bus_clock;
-        current_cpu_data.memory_clock = memory_clock;
-        current_cpu_data.module_clock = module_clock;
-}
-#endif
+void (*board_time_init)(void);
 
 void __init time_init(void)
 {
-        unsigned int timer_freq = 0;
-        unsigned int ifc, pfc, bfc;
-        unsigned long interval;
-#ifdef CONFIG_CPU_SUBTYPE_ST40STB1
-        unsigned long pvr;
-        unsigned short frqcr;
-#endif
-
         if (board_time_init)
                 board_time_init();
 
-        /*
-         * If we don't have an RTC (such as with the SH7300), don't attempt to
-         * probe the timer frequency. Rely on an either hardcoded peripheral
-         * clock value, or on the sh_pclk command line option. Note that we
-         * still need to have CONFIG_SH_PCLK_FREQ set in order for things like
-         * CLOCK_TICK_RATE to be sane.
-         */
-        current_cpu_data.module_clock = sh_pclk_freq;
-
-#ifdef CONFIG_SH_PCLK_CALC
-        /* XXX: Switch this over to a more generic test. */
-        {
-                unsigned int freq;
-
-                /*
-                 * If we've specified a peripheral clock frequency, and we have
-                 * an RTC, compare it against the autodetected value. Complain
-                 * if there's a mismatch.
-                 */
-                timer_freq = get_timer_frequency();
-                freq = timer_freq * 4;
-
-                if (sh_pclk_freq && (sh_pclk_freq/100*99 > freq || sh_pclk_freq/100*101 < freq)) {
-                        printk(KERN_NOTICE "Calculated peripheral clock value "
-                               "%d differs from sh_pclk value %d, fixing..\n",
-                               freq, sh_pclk_freq);
-                        current_cpu_data.module_clock = freq;
-                }
-        }
-#endif
-
-#ifdef CONFIG_CPU_SUBTYPE_ST40STB1
-        /* XXX: Update ST40 code to use board_time_init() */
-        pvr = ctrl_inl(CCN_PVR);
-        frqcr = ctrl_inw(FRQCR);
-        printk("time.c ST40 Probe: PVR %08lx, FRQCR %04hx\n", pvr, frqcr);
-
-        if (((pvr >> CCN_PVR_CHIP_SHIFT) & CCN_PVR_CHIP_MASK) == CCN_PVR_CHIP_ST40STB1)
-                st40_specific_time_init(current_cpu_data.module_clock, frqcr);
-        else
-#endif
-                get_current_frequency_divisors(&ifc, &bfc, &pfc);
+        clk_init();
 
         if (rtc_get_time) {
                 rtc_get_time(&xtime);
@@ -594,51 +179,12 @@ void __init time_init(void)
         set_normalized_timespec(&wall_to_monotonic,
                                 -xtime.tv_sec, -xtime.tv_nsec);
 
-        if (board_timer_setup) {
-                board_timer_setup(&irq0);
-        } else {
-                setup_irq(TIMER_IRQ, &irq0);
-        }
-
         /*
-         * for ST40 chips the current_cpu_data should already be set
-         * so not having valid pfc/bfc/ifc shouldn't be a problem
+         * Find the timer to use as the system timer, it will be
+         * initialized for us.
          */
-        if (!current_cpu_data.master_clock)
-                current_cpu_data.master_clock = current_cpu_data.module_clock * pfc;
-        if (!current_cpu_data.bus_clock)
-                current_cpu_data.bus_clock = current_cpu_data.master_clock / bfc;
-        if (!current_cpu_data.cpu_clock)
-                current_cpu_data.cpu_clock = current_cpu_data.master_clock / ifc;
-
-        printk("CPU clock: %d.%02dMHz\n",
-               (current_cpu_data.cpu_clock / 1000000),
-               (current_cpu_data.cpu_clock % 1000000)/10000);
-        printk("Bus clock: %d.%02dMHz\n",
-               (current_cpu_data.bus_clock / 1000000),
-               (current_cpu_data.bus_clock % 1000000)/10000);
-#ifdef CONFIG_CPU_SUBTYPE_ST40STB1
-        printk("Memory clock: %d.%02dMHz\n",
-               (current_cpu_data.memory_clock / 1000000),
-               (current_cpu_data.memory_clock % 1000000)/10000);
-#endif
-        printk("Module clock: %d.%02dMHz\n",
-               (current_cpu_data.module_clock / 1000000),
-               (current_cpu_data.module_clock % 1000000)/10000);
-
-        interval = (current_cpu_data.module_clock/4 + HZ/2) / HZ;
-
-        printk("Interval = %ld\n", interval);
-
-        /* Start TMU0 */
-        ctrl_outb(0, TMU_TSTR);
-#if !defined(CONFIG_CPU_SUBTYPE_SH7300)
-        ctrl_outb(TMU_TOCR_INIT, TMU_TOCR);
-#endif
-        ctrl_outw(TMU0_TCR_INIT, TMU0_TCR);
-        ctrl_outl(interval, TMU0_TCOR);
-        ctrl_outl(interval, TMU0_TCNT);
-        ctrl_outb(TMU_TSTR_INIT, TMU_TSTR);
+        sys_timer = get_sys_timer();
+        printk(KERN_INFO "Using %s for system timer\n", sys_timer->name);
 
 #if defined(CONFIG_SH_KGDB)
         /*
diff --git a/arch/sh/kernel/timers/Makefile b/arch/sh/kernel/timers/Makefile
new file mode 100644
index 000000000000..151a6a304cec
--- /dev/null
+++ b/arch/sh/kernel/timers/Makefile
@@ -0,0 +1,8 @@
+#
+# Makefile for the various Linux/SuperH timers
+#
+
+obj-y   := timer.o
+
+obj-$(CONFIG_SH_TMU)            += timer-tmu.o
+
diff --git a/arch/sh/kernel/timers/timer-tmu.c b/arch/sh/kernel/timers/timer-tmu.c
new file mode 100644
index 000000000000..96a64cb13106
--- /dev/null
+++ b/arch/sh/kernel/timers/timer-tmu.c
@@ -0,0 +1,229 @@
+/*
+ * arch/sh/kernel/timers/timer-tmu.c - TMU Timer Support
+ *
+ *  Copyright (C) 2005  Paul Mundt
+ *
+ * TMU handling code hacked out of arch/sh/kernel/time.c
+ *
+ *  Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
+ *  Copyright (C) 2000  Philipp Rumpf <prumpf@tux.org>
+ *  Copyright (C) 2002, 2003, 2004  Paul Mundt
+ *  Copyright (C) 2002  M. R. Brown  <mrbrown@linux-sh.org>
+ *
+ * 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.
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/interrupt.h>
+#include <linux/spinlock.h>
+#include <linux/seqlock.h>
+#include <asm/timer.h>
+#include <asm/rtc.h>
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/clock.h>
+
+#define TMU_TOCR_INIT   0x00
+#define TMU0_TCR_INIT   0x0020
+#define TMU_TSTR_INIT   1
+
+#define TMU0_TCR_CALIB  0x0000
+
+static DEFINE_SPINLOCK(tmu0_lock);
+
+static unsigned long tmu_timer_get_offset(void)
+{
+        int count;
+        unsigned long flags;
+
+        static int count_p = 0x7fffffff;    /* for the first call after boot */
+        static unsigned long jiffies_p = 0;
+
+        /*
+         * cache volatile jiffies temporarily; we have IRQs turned off.
+         */
+        unsigned long jiffies_t;
+
+        spin_lock_irqsave(&tmu0_lock, flags);
+        /* timer count may underflow right here */
+        count = ctrl_inl(TMU0_TCNT);    /* read the latched count */
+
+        jiffies_t = jiffies;
+
+        /*
+         * avoiding timer inconsistencies (they are rare, but they happen)...
+         * there is one kind of problem that must be avoided here:
+         *  1. the timer counter underflows
+         */
+
+        if (jiffies_t == jiffies_p) {
+                if (count > count_p) {
+                        /* the nutcase */
+                        if (ctrl_inw(TMU0_TCR) & 0x100) { /* Check UNF bit */
+                                count -= LATCH;
+                        } else {
+                                printk("%s (): hardware timer problem?\n",
+                                       __FUNCTION__);
+                        }
+                }
+        } else
+                jiffies_p = jiffies_t;
+
+        count_p = count;
+        spin_unlock_irqrestore(&tmu0_lock, flags);
+
+        count = ((LATCH-1) - count) * TICK_SIZE;
+        count = (count + LATCH/2) / LATCH;
+
+        return count;
+}
+
+static irqreturn_t tmu_timer_interrupt(int irq, void *dev_id,
+                                       struct pt_regs *regs)
+{
+        unsigned long timer_status;
+
+        /* Clear UNF bit */
+        timer_status = ctrl_inw(TMU0_TCR);
+        timer_status &= ~0x100;
+        ctrl_outw(timer_status, TMU0_TCR);
+
+        /*
+         * Here we are in the timer irq handler. We just have irqs locally
+         * disabled but we don't know if the timer_bh is running on the other
+         * CPU. We need to avoid to SMP race with it. NOTE: we don' t need
+         * the irq version of write_lock because as just said we have irq
+         * locally disabled. -arca
+         */
+        write_seqlock(&xtime_lock);
+        handle_timer_tick(regs);
+        write_sequnlock(&xtime_lock);
+
+        return IRQ_HANDLED;
+}
+
+static struct irqaction tmu_irq = {
+        .name           = "timer",
+        .handler        = tmu_timer_interrupt,
+        .flags          = SA_INTERRUPT,
+        .mask           = CPU_MASK_NONE,
+};
+
+/*
+ * Hah!  We'll see if this works (switching from usecs to nsecs).
+ */
+static unsigned long tmu_timer_get_frequency(void)
+{
+        u32 freq;
+        struct timespec ts1, ts2;
+        unsigned long diff_nsec;
+        unsigned long factor;
+
+        /* Setup the timer:  We don't want to generate interrupts, just
+         * have it count down at its natural rate.
+         */
+        ctrl_outb(0, TMU_TSTR);
+#if !defined(CONFIG_CPU_SUBTYPE_SH7300) && !defined(CONFIG_CPU_SUBTYPE_SH7760)
+        ctrl_outb(TMU_TOCR_INIT, TMU_TOCR);
+#endif
+        ctrl_outw(TMU0_TCR_CALIB, TMU0_TCR);
+        ctrl_outl(0xffffffff, TMU0_TCOR);
+        ctrl_outl(0xffffffff, TMU0_TCNT);
+
+        rtc_get_time(&ts2);
+
+        do {
+                rtc_get_time(&ts1);
+        } while (ts1.tv_nsec == ts2.tv_nsec && ts1.tv_sec == ts2.tv_sec);
+
+        /* actually start the timer */
+        ctrl_outb(TMU_TSTR_INIT, TMU_TSTR);
+
+        do {
+                rtc_get_time(&ts2);
+        } while (ts1.tv_nsec == ts2.tv_nsec && ts1.tv_sec == ts2.tv_sec);
+
+        freq = 0xffffffff - ctrl_inl(TMU0_TCNT);
+        if (ts2.tv_nsec < ts1.tv_nsec) {
+                ts2.tv_nsec += 1000000000;
+                ts2.tv_sec--;
+        }
+
+        diff_nsec = (ts2.tv_sec - ts1.tv_sec) * 1000000000 + (ts2.tv_nsec - ts1.tv_nsec);
+
+        /* this should work well if the RTC has a precision of n Hz, where
+         * n is an integer.  I don't think we have to worry about the other
+         * cases. */
+        factor = (1000000000 + diff_nsec/2) / diff_nsec;
+
+        if (factor * diff_nsec > 1100000000 ||
+            factor * diff_nsec <  900000000)
+                panic("weird RTC (diff_nsec %ld)", diff_nsec);
+
+        return freq * factor;
+}
+
+static void tmu_clk_init(struct clk *clk)
+{
+        u8 divisor = TMU0_TCR_INIT & 0x7;
+        ctrl_outw(TMU0_TCR_INIT, TMU0_TCR);
+        clk->rate = clk->parent->rate / (4 << (divisor << 1));
+}
+
+static void tmu_clk_recalc(struct clk *clk)
+{
+        u8 divisor = ctrl_inw(TMU0_TCR) & 0x7;
+        clk->rate = clk->parent->rate / (4 << (divisor << 1));
+}
+
+static struct clk_ops tmu_clk_ops = {
+        .init           = tmu_clk_init,
+        .recalc         = tmu_clk_recalc,
+};
+
+static struct clk tmu0_clk = {
+        .name           = "tmu0_clk",
+        .ops            = &tmu_clk_ops,
+};
+
+static int tmu_timer_init(void)
+{
+        unsigned long interval;
+
+        setup_irq(TIMER_IRQ, &tmu_irq);
+
+        tmu0_clk.parent = clk_get("module_clk");
+
+        /* Start TMU0 */
+        ctrl_outb(0, TMU_TSTR);
+#if !defined(CONFIG_CPU_SUBTYPE_SH7300) && !defined(CONFIG_CPU_SUBTYPE_SH7760)
+        ctrl_outb(TMU_TOCR_INIT, TMU_TOCR);
+#endif
+
+        clk_register(&tmu0_clk);
+        clk_enable(&tmu0_clk);
+
+        interval = (clk_get_rate(&tmu0_clk) + HZ / 2) / HZ;
+        printk(KERN_INFO "Interval = %ld\n", interval);
+
+        ctrl_outl(interval, TMU0_TCOR);
+        ctrl_outl(interval, TMU0_TCNT);
+
+        ctrl_outb(TMU_TSTR_INIT, TMU_TSTR);
+
+        return 0;
+}
+
+struct sys_timer_ops tmu_timer_ops = {
+        .init           = tmu_timer_init,
+        .get_frequency  = tmu_timer_get_frequency,
+        .get_offset     = tmu_timer_get_offset,
+};
+
+struct sys_timer tmu_timer = {
+        .name   = "tmu",
+        .ops    = &tmu_timer_ops,
+};
+
diff --git a/arch/sh/kernel/timers/timer.c b/arch/sh/kernel/timers/timer.c
new file mode 100644
index 000000000000..dc1f631053a8
--- /dev/null
+++ b/arch/sh/kernel/timers/timer.c
@@ -0,0 +1,50 @@
+/*
+ * arch/sh/kernel/timers/timer.c - Common timer code
+ *
+ *  Copyright (C) 2005  Paul Mundt
+ *
+ * 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.
+ */
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/timer.h>
+#include <linux/string.h>
+#include <asm/timer.h>
+
+static struct sys_timer *sys_timers[] __initdata = {
+#ifdef CONFIG_SH_TMU
+        &tmu_timer,
+#endif
+        NULL,
+};
+
+static char timer_override[10] __initdata;
+static int __init timer_setup(char *str)
+{
+        if (str)
+                strlcpy(timer_override, str, sizeof(timer_override));
+        return 1;
+}
+__setup("timer=", timer_setup);
+
+struct sys_timer *get_sys_timer(void)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(sys_timers); i++) {
+                struct sys_timer *t = sys_timers[i];
+
+                if (unlikely(!t))
+                        break;
+                if (unlikely(timer_override[0]))
+                        if ((strcmp(timer_override, t->name) != 0))
+                                continue;
+                if (likely(t->ops->init() == 0))
+                        return t;
+        }
+
+        return NULL;
+}
+
diff --git a/arch/sh/mm/Kconfig b/arch/sh/mm/Kconfig
new file mode 100644
index 000000000000..fb586b1cf8bb
--- /dev/null
+++ b/arch/sh/mm/Kconfig
@@ -0,0 +1,233 @@
+menu "Processor selection"
+
+#
+# Processor families
+#
+config CPU_SH2
+        bool
+        select SH_WRITETHROUGH
+
+config CPU_SH3
+        bool
+        select CPU_HAS_INTEVT
+        select CPU_HAS_SR_RB
+
+config CPU_SH4
+        bool
+        select CPU_HAS_INTEVT
+        select CPU_HAS_SR_RB
+
+config CPU_SH4A
+        bool
+        select CPU_SH4
+        select CPU_HAS_INTC2_IRQ
+
+config CPU_SUBTYPE_ST40
+        bool
+        select CPU_SH4
+        select CPU_HAS_INTC2_IRQ
+
+#
+# Processor subtypes
+#
+
+comment "SH-2 Processor Support"
+
+config CPU_SUBTYPE_SH7604
+        bool "Support SH7604 processor"
+        select CPU_SH2
+
+comment "SH-3 Processor Support"
+
+config CPU_SUBTYPE_SH7300
+        bool "Support SH7300 processor"
+        select CPU_SH3
+
+config CPU_SUBTYPE_SH7705
+        bool "Support SH7705 processor"
+        select CPU_SH3
+        select CPU_HAS_PINT_IRQ
+
+config CPU_SUBTYPE_SH7707
+        bool "Support SH7707 processor"
+        select CPU_SH3
+        select CPU_HAS_PINT_IRQ
+        help
+          Select SH7707 if you have a  60 Mhz SH-3 HD6417707 CPU.
+
+config CPU_SUBTYPE_SH7708
+        bool "Support SH7708 processor"
+        select CPU_SH3
+        help
+          Select SH7708 if you have a  60 Mhz SH-3 HD6417708S or
+          if you have a 100 Mhz SH-3 HD6417708R CPU.
+
+config CPU_SUBTYPE_SH7709
+        bool "Support SH7709 processor"
+        select CPU_SH3
+        select CPU_HAS_PINT_IRQ
+        help
+          Select SH7709 if you have a  80 Mhz SH-3 HD6417709 CPU.
+
+comment "SH-4 Processor Support"
+
+config CPU_SUBTYPE_SH7750
+        bool "Support SH7750 processor"
+        select CPU_SH4
+        help
+          Select SH7750 if you have a 200 Mhz SH-4 HD6417750 CPU.
+
+config CPU_SUBTYPE_SH7091
+        bool "Support SH7091 processor"
+        select CPU_SH4
+        select CPU_SUBTYPE_SH7750
+        help
+          Select SH7091 if you have an SH-4 based Sega device (such as
+          the Dreamcast, Naomi, and Naomi 2).
+
+config CPU_SUBTYPE_SH7750R
+        bool "Support SH7750R processor"
+        select CPU_SH4
+        select CPU_SUBTYPE_SH7750
+
+config CPU_SUBTYPE_SH7750S
+        bool "Support SH7750S processor"
+        select CPU_SH4
+        select CPU_SUBTYPE_SH7750
+
+config CPU_SUBTYPE_SH7751
+        bool "Support SH7751 processor"
+        select CPU_SH4
+        help
+          Select SH7751 if you have a 166 Mhz SH-4 HD6417751 CPU,
+          or if you have a HD6417751R CPU.
+
+config CPU_SUBTYPE_SH7751R
+        bool "Support SH7751R processor"
+        select CPU_SH4
+        select CPU_SUBTYPE_SH7751
+
+config CPU_SUBTYPE_SH7760
+        bool "Support SH7760 processor"
+        select CPU_SH4
+        select CPU_HAS_INTC2_IRQ
+
+config CPU_SUBTYPE_SH4_202
+        bool "Support SH4-202 processor"
+        select CPU_SH4
+
+comment "ST40 Processor Support"
+
+config CPU_SUBTYPE_ST40STB1
+        bool "Support ST40STB1/ST40RA processors"
+        select CPU_SUBTYPE_ST40
+        help
+          Select ST40STB1 if you have a ST40RA CPU.
+          This was previously called the ST40STB1, hence the option name.
+
+config CPU_SUBTYPE_ST40GX1
+        bool "Support ST40GX1 processor"
+        select CPU_SUBTYPE_ST40
+        help
+          Select ST40GX1 if you have a ST40GX1 CPU.
+
+comment "SH-4A Processor Support"
+
+config CPU_SUBTYPE_SH73180
+        bool "Support SH73180 processor"
+        select CPU_SH4A
+
+config CPU_SUBTYPE_SH7770
+        bool "Support SH7770 processor"
+        select CPU_SH4A
+
+config CPU_SUBTYPE_SH7780
+        bool "Support SH7780 processor"
+        select CPU_SH4A
+
+endmenu
+
+menu "Memory management options"
+
+config MMU
+        bool "Support for memory management hardware"
+        depends on !CPU_SH2
+        default y
+        help
+          Some SH processors (such as SH-2/SH-2A) lack an MMU. In order to
+          boot on these systems, this option must not be set.
+
+          On other systems (such as the SH-3 and 4) where an MMU exists,
+          turning this off will boot the kernel on these machines with the
+          MMU implicitly switched off.
+
+config 32BIT
+        bool "Support 32-bit physical addressing through PMB"
+        depends on CPU_SH4A
+        default y
+        help
+          If you say Y here, physical addressing will be extended to
+          32-bits through the SH-4A PMB. If this is not set, legacy
+          29-bit physical addressing will be used.
+
+choice
+        prompt "HugeTLB page size"
+        depends on HUGETLB_PAGE && CPU_SH4 && MMU
+        default HUGETLB_PAGE_SIZE_64K
+
+config HUGETLB_PAGE_SIZE_64K
+        bool "64K"
+
+config HUGETLB_PAGE_SIZE_1MB
+        bool "1MB"
+
+endchoice
+
+source "mm/Kconfig"
+
+endmenu
+
+menu "Cache configuration"
+
+config SH7705_CACHE_32KB
+        bool "Enable 32KB cache size for SH7705"
+        depends on CPU_SUBTYPE_SH7705
+        default y
+
+config SH_DIRECT_MAPPED
+        bool "Use direct-mapped caching"
+        default n
+        help
+          Selecting this option will configure the caches to be direct-mapped,
+          even if the cache supports a 2 or 4-way mode. This is useful primarily
+          for debugging on platforms with 2 and 4-way caches (SH7750R/SH7751R,
+          SH4-202, SH4-501, etc.)
+
+          Turn this option off for platforms that do not have a direct-mapped
+          cache, and you have no need to run the caches in such a configuration.
+
+config SH_WRITETHROUGH
+        bool "Use write-through caching"
+        default y if CPU_SH2
+        help
+          Selecting this option will configure the caches in write-through
+          mode, as opposed to the default write-back configuration.
+
+          Since there's sill some aliasing issues on SH-4, this option will
+          unfortunately still require the majority of flushing functions to
+          be implemented to deal with aliasing.
+
+          If unsure, say N.
+
+config SH_OCRAM
+        bool "Operand Cache RAM (OCRAM) support"
+        help
+          Selecting this option will automatically tear down the number of
+          sets in the dcache by half, which in turn exposes a memory range.
+
+          The addresses for the OC RAM base will vary according to the
+          processor version. Consult vendor documentation for specifics.
+
+          If unsure, say N.
+
+endmenu
diff --git a/arch/sh/mm/ioremap.c b/arch/sh/mm/ioremap.c
index e794e27a72f1..96fa4a999e2a 100644
--- a/arch/sh/mm/ioremap.c
+++ b/arch/sh/mm/ioremap.c
@@ -6,13 +6,19 @@
  * 640k-1MB IO memory area on PC's
  *
  * (C) Copyright 1995 1996 Linus Torvalds
+ * (C) Copyright 2005, 2006 Paul Mundt
+ *
+ * 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.
  */
-
 #include <linux/vmalloc.h>
+#include <linux/module.h>
 #include <linux/mm.h>
 #include <asm/io.h>
 #include <asm/page.h>
 #include <asm/pgalloc.h>
+#include <asm/addrspace.h>
 #include <asm/cacheflush.h>
 #include <asm/tlbflush.h>
 
@@ -80,9 +86,15 @@ int remap_area_pages(unsigned long address, unsigned long phys_addr,
         if (address >= end)
                 BUG();
         do {
+                pud_t *pud;
                 pmd_t *pmd;
-                pmd = pmd_alloc(&init_mm, dir, address);
+
                 error = -ENOMEM;
+
+                pud = pud_alloc(&init_mm, dir, address);
+                if (!pud)
+                        break;
+                pmd = pmd_alloc(&init_mm, pud, address);
                 if (!pmd)
                         break;
                 if (remap_area_pmd(pmd, address, end - address,
@@ -97,10 +109,6 @@ int remap_area_pages(unsigned long address, unsigned long phys_addr,
 }
 
 /*
- * Generic mapping function (not visible outside):
- */
-
-/*
  * Remap an arbitrary physical address space into the kernel virtual
  * address space. Needed when the kernel wants to access high addresses
  * directly.
@@ -109,11 +117,11 @@ int remap_area_pages(unsigned long address, unsigned long phys_addr,
  * have to convert them into an offset in a page-aligned mapping, but the
  * caller shouldn't need to know that small detail.
  */
-void * p3_ioremap(unsigned long phys_addr, unsigned long size, unsigned long flags)
+void __iomem *__ioremap(unsigned long phys_addr, unsigned long size,
+                        unsigned long flags)
 {
-        void * addr;
         struct vm_struct * area;
-        unsigned long offset, last_addr;
+        unsigned long offset, last_addr, addr, orig_addr;
 
         /* Don't allow wraparound or zero size */
         last_addr = phys_addr + size - 1;
@@ -124,7 +132,7 @@ void * p3_ioremap(unsigned long phys_addr, unsigned long size, unsigned long fla
          * Don't remap the low PCI/ISA area, it's always mapped..
          */
         if (phys_addr >= 0xA0000 && last_addr < 0x100000)
-                return phys_to_virt(phys_addr);
+                return (void __iomem *)phys_to_virt(phys_addr);
 
         /*
          * Don't allow anybody to remap normal RAM that we're using..
@@ -146,16 +154,71 @@ void * p3_ioremap(unsigned long phys_addr, unsigned long size, unsigned long fla
         if (!area)
                 return NULL;
         area->phys_addr = phys_addr;
-        addr = area->addr;
-        if (remap_area_pages((unsigned long) addr, phys_addr, size, flags)) {
-                vunmap(addr);
-                return NULL;
+        orig_addr = addr = (unsigned long)area->addr;
+
+#ifdef CONFIG_32BIT
+        /*
+         * First try to remap through the PMB once a valid VMA has been
+         * established. Smaller allocations (or the rest of the size
+         * remaining after a PMB mapping due to the size not being
+         * perfectly aligned on a PMB size boundary) are then mapped
+         * through the UTLB using conventional page tables.
+         *
+         * PMB entries are all pre-faulted.
+         */
+        if (unlikely(size >= 0x1000000)) {
+                unsigned long mapped = pmb_remap(addr, phys_addr, size, flags);
+
+                if (likely(mapped)) {
+                        addr            += mapped;
+                        phys_addr       += mapped;
+                        size            -= mapped;
+                }
         }
-        return (void *) (offset + (char *)addr);
+#endif
+
+        if (likely(size))
+                if (remap_area_pages(addr, phys_addr, size, flags)) {
+                        vunmap((void *)orig_addr);
+                        return NULL;
+                }
+
+        return (void __iomem *)(offset + (char *)orig_addr);
 }
+EXPORT_SYMBOL(__ioremap);
 
-void p3_iounmap(void *addr)
+void __iounmap(void __iomem *addr)
 {
-        if (addr > high_memory)
-                vfree((void *)(PAGE_MASK & (unsigned long)addr));
+        unsigned long vaddr = (unsigned long __force)addr;
+        struct vm_struct *p;
+
+        if (PXSEG(vaddr) < P3SEG)
+                return;
+
+#ifdef CONFIG_32BIT
+        /*
+         * Purge any PMB entries that may have been established for this
+         * mapping, then proceed with conventional VMA teardown.
+         *
+         * XXX: Note that due to the way that remove_vm_area() does
+         * matching of the resultant VMA, we aren't able to fast-forward
+         * the address past the PMB space until the end of the VMA where
+         * the page tables reside. As such, unmap_vm_area() will be
+         * forced to linearly scan over the area until it finds the page
+         * tables where PTEs that need to be unmapped actually reside,
+         * which is far from optimal. Perhaps we need to use a separate
+         * VMA for the PMB mappings?
+         *                                      -- PFM.
+         */
+        pmb_unmap(vaddr);
+#endif
+
+        p = remove_vm_area((void *)(vaddr & PAGE_MASK));
+        if (!p) {
+                printk(KERN_ERR "%s: bad address %p\n", __FUNCTION__, addr);
+                return;
+        }
+
+        kfree(p);
 }
+EXPORT_SYMBOL(__iounmap);
diff --git a/arch/sh/tools/mach-types b/arch/sh/tools/mach-types
index 0693fbd1f956..182fe9092577 100644
--- a/arch/sh/tools/mach-types
+++ b/arch/sh/tools/mach-types
@@ -10,10 +10,7 @@ SE			SH_SOLUTION_ENGINE
 7300SE                  SH_7300_SOLUTION_ENGINE
 73180SE                 SH_73180_SOLUTION_ENGINE
 7751SYSTEMH             SH_7751_SYSTEMH
-HP600                   SH_HP600
-HP620                   SH_HP620
-HP680                   SH_HP680
-HP690                   SH_HP690
+HP6XX                   SH_HP6XX
 HD64461                 HD64461
 HD64465                 HD64465
 SH2000                  SH_SH2000
diff --git a/arch/sparc/mm/iommu.c b/arch/sparc/mm/iommu.c
index 489bf68d5f05..77840c804786 100644
--- a/arch/sparc/mm/iommu.c
+++ b/arch/sparc/mm/iommu.c
@@ -295,8 +295,7 @@ static void iommu_release_one(u32 busa, int npages, struct sbus_bus *sbus)
         int ioptex;
         int i;
 
-        if (busa < iommu->start)
-                BUG();
+        BUG_ON(busa < iommu->start);
         ioptex = (busa - iommu->start) >> PAGE_SHIFT;
         for (i = 0; i < npages; i++) {
                 iopte_val(iommu->page_table[ioptex + i]) = 0;
@@ -340,9 +339,9 @@ static int iommu_map_dma_area(dma_addr_t *pba, unsigned long va,
         iopte_t *first;
         int ioptex;
 
-        if ((va & ~PAGE_MASK) != 0) BUG();
-        if ((addr & ~PAGE_MASK) != 0) BUG();
-        if ((len & ~PAGE_MASK) != 0) BUG();
+        BUG_ON((va & ~PAGE_MASK) != 0);
+        BUG_ON((addr & ~PAGE_MASK) != 0);
+        BUG_ON((len & ~PAGE_MASK) != 0);
 
         /* page color = physical address */
         ioptex = bit_map_string_get(&iommu->usemap, len >> PAGE_SHIFT,
@@ -405,8 +404,8 @@ static void iommu_unmap_dma_area(unsigned long busa, int len)
         unsigned long end;
         int ioptex = (busa - iommu->start) >> PAGE_SHIFT;
 
-        if ((busa & ~PAGE_MASK) != 0) BUG();
-        if ((len & ~PAGE_MASK) != 0) BUG();
+        BUG_ON((busa & ~PAGE_MASK) != 0);
+        BUG_ON((len & ~PAGE_MASK) != 0);
 
         iopte += ioptex;
         end = busa + len;
diff --git a/arch/sparc64/kernel/time.c b/arch/sparc64/kernel/time.c
index 459c8fbe02b4..a22930d62adf 100644
--- a/arch/sparc64/kernel/time.c
+++ b/arch/sparc64/kernel/time.c
@@ -280,9 +280,9 @@ static struct sparc64_tick_ops stick_operations __read_mostly = {
  * Since STICK is constantly updating, we have to access it carefully.
  *
  * The sequence we use to read is:
- * 1) read low
- * 2) read high
- * 3) read low again, if it rolled over increment high by 1
+ * 1) read high
+ * 2) read low
+ * 3) read high again, if it rolled re-read both low and high again.
  *
  * Writing STICK safely is also tricky:
  * 1) write low to zero
@@ -295,18 +295,18 @@ static struct sparc64_tick_ops stick_operations __read_mostly = {
 static unsigned long __hbird_read_stick(void)
 {
         unsigned long ret, tmp1, tmp2, tmp3;
-        unsigned long addr = HBIRD_STICK_ADDR;
+        unsigned long addr = HBIRD_STICK_ADDR+8;
 
-        __asm__ __volatile__("ldxa      [%1] %5, %2\n\t"
-                             "add       %1, 0x8, %1\n\t"
-                             "ldxa      [%1] %5, %3\n\t"
+        __asm__ __volatile__("ldxa      [%1] %5, %2\n"
+                             "1:\n\t"
                              "sub       %1, 0x8, %1\n\t"
+                             "ldxa      [%1] %5, %3\n\t"
+                             "add       %1, 0x8, %1\n\t"
                              "ldxa      [%1] %5, %4\n\t"
                              "cmp       %4, %2\n\t"
-                             "blu,a,pn  %%xcc, 1f\n\t"
-                             " add      %3, 1, %3\n"
-                             "1:\n\t"
-                             "sllx      %3, 32, %3\n\t"
+                             "bne,a,pn  %%xcc, 1b\n\t"
+                             " mov      %4, %2\n\t"
+                             "sllx      %4, 32, %4\n\t"
                              "or        %3, %4, %0\n\t"
                              : "=&r" (ret), "=&r" (addr),
                                "=&r" (tmp1), "=&r" (tmp2), "=&r" (tmp3)
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)
diff --git a/arch/um/include/sysdep-i386/checksum.h b/arch/um/include/sysdep-i386/checksum.h
index 764ba4db4788..7d3d202d7fff 100644
--- a/arch/um/include/sysdep-i386/checksum.h
+++ b/arch/um/include/sysdep-i386/checksum.h
@@ -36,7 +36,7 @@ unsigned int csum_partial_copy_nocheck(const unsigned char *src, unsigned char *
                                        int len, int sum)
 {
         memcpy(dst, src, len);
-        return(csum_partial(dst, len, sum));
+        return csum_partial(dst, len, sum);
 }
 
 /*
@@ -104,7 +104,7 @@ static inline unsigned short ip_fast_csum(unsigned char * iph,
         : "=r" (sum), "=r" (iph), "=r" (ihl)
         : "1" (iph), "2" (ihl)
         : "memory");
-        return(sum);
+        return sum;
 }
 
 /*
diff --git a/arch/x86_64/Kconfig b/arch/x86_64/Kconfig
index 2efc4be22709..2f9deca31cc9 100644
--- a/arch/x86_64/Kconfig
+++ b/arch/x86_64/Kconfig
@@ -305,7 +305,11 @@ config ARCH_DISCONTIGMEM_DEFAULT
 
 config ARCH_SPARSEMEM_ENABLE
         def_bool y
-        depends on NUMA
+        depends on (NUMA || EXPERIMENTAL)
+
+config ARCH_MEMORY_PROBE
+        def_bool y
+        depends on MEMORY_HOTPLUG
 
 config ARCH_FLATMEM_ENABLE
         def_bool y
@@ -315,6 +319,7 @@ source "mm/Kconfig"
 
 config HAVE_ARCH_EARLY_PFN_TO_NID
         def_bool y
+        depends on NUMA
 
 config NR_CPUS
         int "Maximum number of CPUs (2-256)"
@@ -350,7 +355,7 @@ config HPET_TIMER
           <http://www.intel.com/hardwaredesign/hpetspec.htm>.
 
 config X86_PM_TIMER
-        bool "PM timer"
+        bool "PM timer" if EMBEDDED
         depends on ACPI
         default y
         help
diff --git a/arch/x86_64/defconfig b/arch/x86_64/defconfig
index 054dcd8a5e9d..5231fe83ea4b 100644
--- a/arch/x86_64/defconfig
+++ b/arch/x86_64/defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.15-git7
-# Wed Jan 11 11:57:36 2006
+# Linux kernel version: 2.6.15-git12
+# Mon Jan 16 13:09:08 2006
 #
 CONFIG_X86_64=y
 CONFIG_64BIT=y
@@ -319,6 +319,11 @@ CONFIG_IPV6=y
 # CONFIG_ATALK is not set
 # CONFIG_X25 is not set
 # CONFIG_LAPB is not set
+
+#
+# TIPC Configuration (EXPERIMENTAL)
+#
+# CONFIG_TIPC is not set
 # CONFIG_NET_DIVERT is not set
 # CONFIG_ECONET is not set
 # CONFIG_WAN_ROUTER is not set
@@ -537,8 +542,7 @@ CONFIG_SCSI_SATA_INTEL_COMBINED=y
 # CONFIG_SCSI_IPR is not set
 # CONFIG_SCSI_QLOGIC_FC is not set
 # CONFIG_SCSI_QLOGIC_1280 is not set
-CONFIG_SCSI_QLA2XXX=y
-# CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE is not set
+# CONFIG_SCSI_QLA_FC is not set
 # CONFIG_SCSI_LPFC is not set
 # CONFIG_SCSI_DC395x is not set
 # CONFIG_SCSI_DC390T is not set
@@ -805,6 +809,7 @@ CONFIG_SOFT_WATCHDOG=y
 # CONFIG_W83877F_WDT is not set
 # CONFIG_W83977F_WDT is not set
 # CONFIG_MACHZ_WDT is not set
+# CONFIG_SBC_EPX_C3_WATCHDOG is not set
 
 #
 # PCI-based Watchdog Cards
@@ -850,6 +855,12 @@ CONFIG_HPET_MMAP=y
 # CONFIG_I2C is not set
 
 #
+# SPI support
+#
+# CONFIG_SPI is not set
+# CONFIG_SPI_MASTER is not set
+
+#
 # Dallas's 1-wire bus
 #
 # CONFIG_W1 is not set
@@ -992,6 +1003,7 @@ CONFIG_USB_STORAGE=y
 #
 CONFIG_USB_HID=y
 CONFIG_USB_HIDINPUT=y
+# CONFIG_USB_HIDINPUT_POWERBOOK is not set
 # CONFIG_HID_FF is not set
 # CONFIG_USB_HIDDEV is not set
 # CONFIG_USB_AIPTEK is not set
@@ -1276,6 +1288,7 @@ CONFIG_DETECT_SOFTLOCKUP=y
 CONFIG_DEBUG_FS=y
 # CONFIG_DEBUG_VM is not set
 # CONFIG_FRAME_POINTER is not set
+# CONFIG_FORCED_INLINING is not set
 # CONFIG_RCU_TORTURE_TEST is not set
 CONFIG_INIT_DEBUG=y
 # CONFIG_DEBUG_RODATA is not set
diff --git a/arch/x86_64/ia32/Makefile b/arch/x86_64/ia32/Makefile
index 051608d55920..929e6b0771f8 100644
--- a/arch/x86_64/ia32/Makefile
+++ b/arch/x86_64/ia32/Makefile
@@ -3,7 +3,8 @@
 #
 
 obj-$(CONFIG_IA32_EMULATION) := ia32entry.o sys_ia32.o ia32_signal.o tls32.o \
-        ia32_binfmt.o fpu32.o ptrace32.o syscall32.o syscall32_syscall.o
+        ia32_binfmt.o fpu32.o ptrace32.o syscall32.o syscall32_syscall.o \
+        mmap32.o
 
 sysv-$(CONFIG_SYSVIPC) := ipc32.o
 obj-$(CONFIG_IA32_EMULATION) += $(sysv-y)
diff --git a/arch/x86_64/ia32/ia32_binfmt.c b/arch/x86_64/ia32/ia32_binfmt.c
index 029bddab0459..572b3b28772d 100644
--- a/arch/x86_64/ia32/ia32_binfmt.c
+++ b/arch/x86_64/ia32/ia32_binfmt.c
@@ -293,8 +293,6 @@ int ia32_setup_arg_pages(struct linux_binprm *bprm, unsigned long stack_top, int
 } while(0) 
 
 
-#define elf_map elf32_map
-
 #include <linux/module.h>
 
 MODULE_DESCRIPTION("Binary format loader for compatibility with IA32 ELF binaries."); 
@@ -390,21 +388,6 @@ int ia32_setup_arg_pages(struct linux_binprm *bprm, unsigned long stack_top,
 }
 EXPORT_SYMBOL(ia32_setup_arg_pages);
 
-static unsigned long
-elf32_map (struct file *filep, unsigned long addr, struct elf_phdr *eppnt, int prot, int type)
-{
-        unsigned long map_addr;
-        struct task_struct *me = current; 
-
-        down_write(&me->mm->mmap_sem);
-        map_addr = do_mmap(filep, ELF_PAGESTART(addr),
-                           eppnt->p_filesz + ELF_PAGEOFFSET(eppnt->p_vaddr), prot, 
-                           type,
-                           eppnt->p_offset - ELF_PAGEOFFSET(eppnt->p_vaddr));
-        up_write(&me->mm->mmap_sem);
-        return(map_addr);
-}
-
 #ifdef CONFIG_SYSCTL
 /* Register vsyscall32 into the ABI table */
 #include <linux/sysctl.h>
diff --git a/arch/x86_64/ia32/mmap32.c b/arch/x86_64/ia32/mmap32.c
new file mode 100644
index 000000000000..079f4132575c
--- /dev/null
+++ b/arch/x86_64/ia32/mmap32.c
@@ -0,0 +1,78 @@
+/*
+ *  linux/arch/x86_64/ia32/mm/mmap.c
+ *
+ *  flexible mmap layout support
+ *
+ * Based on the i386 version which was
+ *
+ * Copyright 2003-2004 Red Hat Inc., Durham, North Carolina.
+ * All Rights Reserved.
+ *
+ * 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
+ *
+ *
+ * Started by Ingo Molnar <mingo@elte.hu>
+ */
+
+#include <linux/personality.h>
+#include <linux/mm.h>
+#include <linux/random.h>
+
+/*
+ * Top of mmap area (just below the process stack).
+ *
+ * Leave an at least ~128 MB hole.
+ */
+#define MIN_GAP (128*1024*1024)
+#define MAX_GAP (TASK_SIZE/6*5)
+
+static inline unsigned long mmap_base(struct mm_struct *mm)
+{
+        unsigned long gap = current->signal->rlim[RLIMIT_STACK].rlim_cur;
+        unsigned long random_factor = 0;
+
+        if (current->flags & PF_RANDOMIZE)
+                random_factor = get_random_int() % (1024*1024);
+
+        if (gap < MIN_GAP)
+                gap = MIN_GAP;
+        else if (gap > MAX_GAP)
+                gap = MAX_GAP;
+
+        return PAGE_ALIGN(TASK_SIZE - gap - random_factor);
+}
+
+/*
+ * This function, called very early during the creation of a new
+ * process VM image, sets up which VM layout function to use:
+ */
+void ia32_pick_mmap_layout(struct mm_struct *mm)
+{
+        /*
+         * Fall back to the standard layout if the personality
+         * bit is set, or if the expected stack growth is unlimited:
+         */
+        if (sysctl_legacy_va_layout ||
+                        (current->personality & ADDR_COMPAT_LAYOUT) ||
+                        current->signal->rlim[RLIMIT_STACK].rlim_cur == RLIM_INFINITY) {
+                mm->mmap_base = TASK_UNMAPPED_BASE;
+                mm->get_unmapped_area = arch_get_unmapped_area;
+                mm->unmap_area = arch_unmap_area;
+        } else {
+                mm->mmap_base = mmap_base(mm);
+                mm->get_unmapped_area = arch_get_unmapped_area_topdown;
+                mm->unmap_area = arch_unmap_area_topdown;
+        }
+}
diff --git a/arch/x86_64/kernel/apic.c b/arch/x86_64/kernel/apic.c
index 8fdd089fd17e..5d3c5b07b8db 100644
--- a/arch/x86_64/kernel/apic.c
+++ b/arch/x86_64/kernel/apic.c
@@ -499,13 +499,10 @@ static int lapic_resume(struct sys_device *dev)
         if (!apic_pm_state.active)
                 return 0;
 
-        /* XXX: Pavel needs this for S3 resume, but can't explain why */
-        set_fixmap_nocache(FIX_APIC_BASE, APIC_DEFAULT_PHYS_BASE);
-
         local_irq_save(flags);
         rdmsr(MSR_IA32_APICBASE, l, h);
         l &= ~MSR_IA32_APICBASE_BASE;
-        l |= MSR_IA32_APICBASE_ENABLE | APIC_DEFAULT_PHYS_BASE;
+        l |= MSR_IA32_APICBASE_ENABLE | mp_lapic_addr;
         wrmsr(MSR_IA32_APICBASE, l, h);
         apic_write(APIC_LVTERR, ERROR_APIC_VECTOR | APIC_LVT_MASKED);
         apic_write(APIC_ID, apic_pm_state.apic_id);
diff --git a/arch/x86_64/kernel/asm-offsets.c b/arch/x86_64/kernel/asm-offsets.c
index cfb4f9cebea4..38834bbbae11 100644
--- a/arch/x86_64/kernel/asm-offsets.c
+++ b/arch/x86_64/kernel/asm-offsets.c
@@ -43,6 +43,7 @@ int main(void)
         ENTRY(irqcount);
         ENTRY(cpunumber);
         ENTRY(irqstackptr);
+        ENTRY(data_offset);
         BLANK();
 #undef ENTRY
 #ifdef CONFIG_IA32_EMULATION
@@ -66,8 +67,6 @@ int main(void)
         DEFINE(pbe_orig_address, offsetof(struct pbe, orig_address));
         DEFINE(pbe_next, offsetof(struct pbe, next));
         BLANK();
-#if DEBUG_STKSZ > EXCEPTION_STKSZ
-        DEFINE(DEBUG_IST, DEBUG_STACK);
-#endif
+        DEFINE(TSS_ist, offsetof(struct tss_struct, ist));
         return 0;
 }
diff --git a/arch/x86_64/kernel/entry.S b/arch/x86_64/kernel/entry.S
index 632fc0f59fcc..dbdba56e8faa 100644
--- a/arch/x86_64/kernel/entry.S
+++ b/arch/x86_64/kernel/entry.S
@@ -41,6 +41,7 @@
 #include <asm/unistd.h>
 #include <asm/thread_info.h>
 #include <asm/hw_irq.h>
+#include <asm/page.h>
 
         .code64
 
@@ -674,9 +675,6 @@ ENTRY(spurious_interrupt)
 
         /* error code is on the stack already */
         /* handle NMI like exceptions that can happen everywhere */
-#ifndef DEBUG_IST
-# define DEBUG_IST 0
-#endif
         .macro paranoidentry sym, ist=0
         SAVE_ALL
         cld
@@ -695,11 +693,11 @@ ENTRY(spurious_interrupt)
         movq ORIG_RAX(%rsp),%rsi
         movq $-1,ORIG_RAX(%rsp)
         .if \ist
-        subq    $EXCEPTION_STACK_SIZE, per_cpu__init_tss + TSS_ist + (\ist - 1) * 8(%rbp)
+        subq    $EXCEPTION_STKSZ, per_cpu__init_tss + TSS_ist + (\ist - 1) * 8(%rbp)
         .endif
         call \sym
         .if \ist
-        addq    $EXCEPTION_STACK_SIZE, per_cpu__init_tss + TSS_ist + (\ist - 1) * 8(%rbp)
+        addq    $EXCEPTION_STKSZ, per_cpu__init_tss + TSS_ist + (\ist - 1) * 8(%rbp)
         .endif
         cli
         .endm
@@ -918,7 +916,7 @@ KPROBE_ENTRY(debug)
         INTR_FRAME
         pushq $0
         CFI_ADJUST_CFA_OFFSET 8         
-        paranoidentry do_debug, DEBUG_IST
+        paranoidentry do_debug, DEBUG_STACK
         jmp paranoid_exit
         CFI_ENDPROC
         .previous .text
@@ -976,7 +974,7 @@ KPROBE_ENTRY(int3)
         INTR_FRAME
         pushq $0
         CFI_ADJUST_CFA_OFFSET 8
-        paranoidentry do_int3, DEBUG_IST
+        paranoidentry do_int3, DEBUG_STACK
         jmp paranoid_exit
         CFI_ENDPROC
         .previous .text
diff --git a/arch/x86_64/kernel/head.S b/arch/x86_64/kernel/head.S
index 38fc3d5112e7..692c737feddb 100644
--- a/arch/x86_64/kernel/head.S
+++ b/arch/x86_64/kernel/head.S
@@ -241,104 +241,70 @@ ljumpvector:
 ENTRY(stext)
 ENTRY(_stext)
 
-.org 0x1000
-ENTRY(init_level4_pgt)
+        $page = 0
+#define NEXT_PAGE(name) \
+        $page = $page + 1; \
+        .org $page * 0x1000; \
+        phys_/**/name = $page * 0x1000 + __PHYSICAL_START; \
+ENTRY(name)
+
+NEXT_PAGE(init_level4_pgt)
         /* This gets initialized in x86_64_start_kernel */
         .fill   512,8,0
 
-.org 0x2000
-ENTRY(level3_ident_pgt)
-        .quad   0x0000000000004007 + __PHYSICAL_START
+NEXT_PAGE(level3_ident_pgt)
+        .quad   phys_level2_ident_pgt | 0x007
         .fill   511,8,0
 
-.org 0x3000
-ENTRY(level3_kernel_pgt)
+NEXT_PAGE(level3_kernel_pgt)
         .fill   510,8,0
         /* (2^48-(2*1024*1024*1024)-((2^39)*511))/(2^30) = 510 */
-        .quad   0x0000000000005007 + __PHYSICAL_START   /* -> level2_kernel_pgt */
+        .quad   phys_level2_kernel_pgt | 0x007
         .fill   1,8,0
 
-.org 0x4000
-ENTRY(level2_ident_pgt)
+NEXT_PAGE(level2_ident_pgt)
         /* 40MB for bootup.     */
-        .quad   0x0000000000000083
-        .quad   0x0000000000200083
-        .quad   0x0000000000400083
-        .quad   0x0000000000600083
-        .quad   0x0000000000800083
-        .quad   0x0000000000A00083
-        .quad   0x0000000000C00083
-        .quad   0x0000000000E00083
-        .quad   0x0000000001000083
-        .quad   0x0000000001200083
-        .quad   0x0000000001400083
-        .quad   0x0000000001600083
-        .quad   0x0000000001800083
-        .quad   0x0000000001A00083
-        .quad   0x0000000001C00083
-        .quad   0x0000000001E00083
-        .quad   0x0000000002000083
-        .quad   0x0000000002200083
-        .quad   0x0000000002400083
-        .quad   0x0000000002600083
+        i = 0
+        .rept 20
+        .quad   i << 21 | 0x083
+        i = i + 1
+        .endr
         /* Temporary mappings for the super early allocator in arch/x86_64/mm/init.c */
         .globl temp_boot_pmds
 temp_boot_pmds:
         .fill   492,8,0
         
-.org 0x5000
-ENTRY(level2_kernel_pgt)
+NEXT_PAGE(level2_kernel_pgt)
         /* 40MB kernel mapping. The kernel code cannot be bigger than that.
            When you change this change KERNEL_TEXT_SIZE in page.h too. */
         /* (2^48-(2*1024*1024*1024)-((2^39)*511)-((2^30)*510)) = 0 */
-        .quad   0x0000000000000183
-        .quad   0x0000000000200183
-        .quad   0x0000000000400183
-        .quad   0x0000000000600183
-        .quad   0x0000000000800183
-        .quad   0x0000000000A00183
-        .quad   0x0000000000C00183
-        .quad   0x0000000000E00183
-        .quad   0x0000000001000183
-        .quad   0x0000000001200183
-        .quad   0x0000000001400183
-        .quad   0x0000000001600183
-        .quad   0x0000000001800183
-        .quad   0x0000000001A00183
-        .quad   0x0000000001C00183
-        .quad   0x0000000001E00183
-        .quad   0x0000000002000183
-        .quad   0x0000000002200183
-        .quad   0x0000000002400183
-        .quad   0x0000000002600183
+        i = 0
+        .rept 20
+        .quad   i << 21 | 0x183
+        i = i + 1
+        .endr
         /* Module mapping starts here */
         .fill   492,8,0
 
-.org 0x6000
-ENTRY(empty_zero_page)
-
-.org 0x7000
-ENTRY(empty_bad_page)
+NEXT_PAGE(empty_zero_page)
 
-.org 0x8000
-ENTRY(empty_bad_pte_table)
+NEXT_PAGE(level3_physmem_pgt)
+        .quad   phys_level2_kernel_pgt | 0x007  /* so that __va works even before pagetable_init */
+        .fill   511,8,0
 
-.org 0x9000
-ENTRY(empty_bad_pmd_table)
+#undef NEXT_PAGE
 
-.org 0xa000
-ENTRY(level3_physmem_pgt)
-        .quad   0x0000000000005007 + __PHYSICAL_START   /* -> level2_kernel_pgt (so that __va works even before pagetable_init) */
+        .data
 
-        .org 0xb000
 #ifdef CONFIG_ACPI_SLEEP
+        .align PAGE_SIZE
 ENTRY(wakeup_level4_pgt)
-        .quad   0x0000000000002007 + __PHYSICAL_START   /* -> level3_ident_pgt */
+        .quad   phys_level3_ident_pgt | 0x007
         .fill   255,8,0
-        .quad   0x000000000000a007 + __PHYSICAL_START
+        .quad   phys_level3_physmem_pgt | 0x007
         .fill   254,8,0
         /* (2^48-(2*1024*1024*1024))/(2^39) = 511 */
-        .quad   0x0000000000003007 + __PHYSICAL_START   /* -> level3_kernel_pgt */
+        .quad   phys_level3_kernel_pgt | 0x007
 #endif
 
 #ifndef CONFIG_HOTPLUG_CPU
@@ -352,12 +318,12 @@ ENTRY(wakeup_level4_pgt)
          */
         .align PAGE_SIZE
 ENTRY(boot_level4_pgt)
-        .quad   0x0000000000002007 + __PHYSICAL_START   /* -> level3_ident_pgt */
+        .quad   phys_level3_ident_pgt | 0x007
         .fill   255,8,0
-        .quad   0x000000000000a007 + __PHYSICAL_START
+        .quad   phys_level3_physmem_pgt | 0x007
         .fill   254,8,0
         /* (2^48-(2*1024*1024*1024))/(2^39) = 511 */
-        .quad   0x0000000000003007 + __PHYSICAL_START   /* -> level3_kernel_pgt */
+        .quad   phys_level3_kernel_pgt | 0x007
 
         .data
 
diff --git a/arch/x86_64/kernel/setup64.c b/arch/x86_64/kernel/setup64.c
index 6eff51e9400c..8ac4db09610a 100644
--- a/arch/x86_64/kernel/setup64.c
+++ b/arch/x86_64/kernel/setup64.c
@@ -38,7 +38,7 @@ struct desc_ptr idt_descr = { 256 * 16, (unsigned long) idt_table };
 char boot_cpu_stack[IRQSTACKSIZE] __attribute__((section(".bss.page_aligned")));
 
 unsigned long __supported_pte_mask __read_mostly = ~0UL;
-static int do_not_nx __initdata = 0;
+static int do_not_nx __cpuinitdata = 0;
 
 /* noexec=on|off
 Control non executable mappings for 64bit processes.
diff --git a/arch/x86_64/mm/Makefile b/arch/x86_64/mm/Makefile
index 1d232a87f113..d25ac86fe27a 100644
--- a/arch/x86_64/mm/Makefile
+++ b/arch/x86_64/mm/Makefile
@@ -2,7 +2,7 @@
 # Makefile for the linux x86_64-specific parts of the memory manager.
 #
 
-obj-y    := init.o fault.o ioremap.o extable.o pageattr.o
+obj-y    := init.o fault.o ioremap.o extable.o pageattr.o mmap.o
 obj-$(CONFIG_HUGETLB_PAGE) += hugetlbpage.o
 obj-$(CONFIG_NUMA) += numa.o
 obj-$(CONFIG_K8_NUMA) += k8topology.o
diff --git a/arch/x86_64/mm/init.c b/arch/x86_64/mm/init.c
index eca60125efc3..7af1742aa958 100644
--- a/arch/x86_64/mm/init.c
+++ b/arch/x86_64/mm/init.c
@@ -24,6 +24,8 @@
 #include <linux/proc_fs.h>
 #include <linux/pci.h>
 #include <linux/dma-mapping.h>
+#include <linux/module.h>
+#include <linux/memory_hotplug.h>
 
 #include <asm/processor.h>
 #include <asm/system.h>
@@ -180,13 +182,19 @@ static  struct temp_map {
         {}
 }; 
 
-static __init void *alloc_low_page(int *index, unsigned long *phys) 
+static __meminit void *alloc_low_page(int *index, unsigned long *phys)
 { 
         struct temp_map *ti;
         int i; 
         unsigned long pfn = table_end++, paddr; 
         void *adr;
 
+        if (after_bootmem) {
+                adr = (void *)get_zeroed_page(GFP_ATOMIC);
+                *phys = __pa(adr);
+                return adr;
+        }
+
         if (pfn >= end_pfn) 
                 panic("alloc_low_page: ran out of memory"); 
         for (i = 0; temp_mappings[i].allocated; i++) {
@@ -199,55 +207,86 @@ static __init void *alloc_low_page(int *index, unsigned long *phys)
         ti->allocated = 1; 
         __flush_tlb();         
         adr = ti->address + ((pfn << PAGE_SHIFT) & ~PMD_MASK); 
+        memset(adr, 0, PAGE_SIZE);
         *index = i; 
         *phys  = pfn * PAGE_SIZE;  
         return adr; 
 } 
 
-static __init void unmap_low_page(int i)
+static __meminit void unmap_low_page(int i)
 { 
-        struct temp_map *ti = &temp_mappings[i];
+        struct temp_map *ti;
+
+        if (after_bootmem)
+                return;
+
+        ti = &temp_mappings[i];
         set_pmd(ti->pmd, __pmd(0));
         ti->allocated = 0; 
 } 
 
-static void __init phys_pud_init(pud_t *pud, unsigned long address, unsigned long end)
+static void __meminit
+phys_pmd_init(pmd_t *pmd, unsigned long address, unsigned long end)
+{
+        int i;
+
+        for (i = 0; i < PTRS_PER_PMD; pmd++, i++, address += PMD_SIZE) {
+                unsigned long entry;
+
+                if (address > end) {
+                        for (; i < PTRS_PER_PMD; i++, pmd++)
+                                set_pmd(pmd, __pmd(0));
+                        break;
+                }
+                entry = _PAGE_NX|_PAGE_PSE|_KERNPG_TABLE|_PAGE_GLOBAL|address;
+                entry &= __supported_pte_mask;
+                set_pmd(pmd, __pmd(entry));
+        }
+}
+
+static void __meminit
+phys_pmd_update(pud_t *pud, unsigned long address, unsigned long end)
+{
+        pmd_t *pmd = pmd_offset(pud, (unsigned long)__va(address));
+
+        if (pmd_none(*pmd)) {
+                spin_lock(&init_mm.page_table_lock);
+                phys_pmd_init(pmd, address, end);
+                spin_unlock(&init_mm.page_table_lock);
+                __flush_tlb_all();
+        }
+}
+
+static void __meminit phys_pud_init(pud_t *pud, unsigned long address, unsigned long end)
 { 
-        long i, j; 
+        long i = pud_index(address);
 
-        i = pud_index(address);
         pud = pud + i;
+
+        if (after_bootmem && pud_val(*pud)) {
+                phys_pmd_update(pud, address, end);
+                return;
+        }
+
         for (; i < PTRS_PER_PUD; pud++, i++) {
                 int map; 
                 unsigned long paddr, pmd_phys;
                 pmd_t *pmd;
 
-                paddr = address + i*PUD_SIZE;
-                if (paddr >= end) { 
-                        for (; i < PTRS_PER_PUD; i++, pud++) 
-                                set_pud(pud, __pud(0)); 
+                paddr = (address & PGDIR_MASK) + i*PUD_SIZE;
+                if (paddr >= end)
                         break;
-                } 
 
-                if (!e820_mapped(paddr, paddr+PUD_SIZE, 0)) { 
+                if (!after_bootmem && !e820_mapped(paddr, paddr+PUD_SIZE, 0)) {
                         set_pud(pud, __pud(0)); 
                         continue;
                 } 
 
                 pmd = alloc_low_page(&map, &pmd_phys);
+                spin_lock(&init_mm.page_table_lock);
                 set_pud(pud, __pud(pmd_phys | _KERNPG_TABLE));
-                for (j = 0; j < PTRS_PER_PMD; pmd++, j++, paddr += PMD_SIZE) {
-                        unsigned long pe;
-
-                        if (paddr >= end) { 
-                                for (; j < PTRS_PER_PMD; j++, pmd++)
-                                        set_pmd(pmd,  __pmd(0)); 
-                                break;
-                }
-                        pe = _PAGE_NX|_PAGE_PSE | _KERNPG_TABLE | _PAGE_GLOBAL | paddr;
-                        pe &= __supported_pte_mask;
-                        set_pmd(pmd, __pmd(pe));
-                }
+                phys_pmd_init(pmd, paddr, end);
+                spin_unlock(&init_mm.page_table_lock);
                 unmap_low_page(map);
         }
         __flush_tlb();
@@ -262,30 +301,25 @@ static void __init find_early_table_space(unsigned long end)
         tables = round_up(puds * sizeof(pud_t), PAGE_SIZE) +
                  round_up(pmds * sizeof(pmd_t), PAGE_SIZE);
 
-        /* Put page tables beyond the DMA zones if possible.
-           RED-PEN might be better to spread them out more over
-           memory to avoid hotspots */
-        if (end > MAX_DMA32_PFN<<PAGE_SHIFT)
-                start = MAX_DMA32_PFN << PAGE_SHIFT;
-        else if (end > MAX_DMA_PFN << PAGE_SHIFT)
-                start = MAX_DMA_PFN << PAGE_SHIFT;
-        else
-                start = 0x8000;
-
-        table_start = find_e820_area(start, end, tables);
-        if (table_start == -1)
-                table_start = find_e820_area(0x8000, end, tables);
+        /* RED-PEN putting page tables only on node 0 could
+           cause a hotspot and fill up ZONE_DMA. The page tables
+           need roughly 0.5KB per GB. */
+        start = 0x8000;
+        table_start = find_e820_area(start, end, tables);
         if (table_start == -1UL)
                 panic("Cannot find space for the kernel page tables");
 
         table_start >>= PAGE_SHIFT;
         table_end = table_start;
+
+        early_printk("kernel direct mapping tables up to %lx @ %lx-%lx\n",
+                end, table_start << PAGE_SHIFT, table_end << PAGE_SHIFT);
 }
 
 /* Setup the direct mapping of the physical memory at PAGE_OFFSET.
    This runs before bootmem is initialized and gets pages directly from the 
    physical memory. To access them they are temporarily mapped. */
-void __init init_memory_mapping(unsigned long start, unsigned long end)
+void __meminit init_memory_mapping(unsigned long start, unsigned long end)
 { 
         unsigned long next; 
 
@@ -297,7 +331,8 @@ void __init init_memory_mapping(unsigned long start, unsigned long end)
          * mapped.  Unfortunately this is done currently before the nodes are 
          * discovered.
          */
-        find_early_table_space(end);
+        if (!after_bootmem)
+                find_early_table_space(end);
 
         start = (unsigned long)__va(start);
         end = (unsigned long)__va(end);
@@ -305,20 +340,26 @@ void __init init_memory_mapping(unsigned long start, unsigned long end)
         for (; start < end; start = next) {
                 int map;
                 unsigned long pud_phys; 
-                pud_t *pud = alloc_low_page(&map, &pud_phys);
+                pgd_t *pgd = pgd_offset_k(start);
+                pud_t *pud;
+
+                if (after_bootmem)
+                        pud = pud_offset_k(pgd, __PAGE_OFFSET);
+                else
+                        pud = alloc_low_page(&map, &pud_phys);
+
                 next = start + PGDIR_SIZE;
                 if (next > end) 
                         next = end; 
                 phys_pud_init(pud, __pa(start), __pa(next));
-                set_pgd(pgd_offset_k(start), mk_kernel_pgd(pud_phys));
+                if (!after_bootmem)
+                        set_pgd(pgd_offset_k(start), mk_kernel_pgd(pud_phys));
                 unmap_low_page(map);   
         } 
 
-        asm volatile("movq %%cr4,%0" : "=r" (mmu_cr4_features));
+        if (!after_bootmem)
+                asm volatile("movq %%cr4,%0" : "=r" (mmu_cr4_features));
         __flush_tlb_all();
-        early_printk("kernel direct mapping tables upto %lx @ %lx-%lx\n", end, 
-               table_start<<PAGE_SHIFT, 
-               table_end<<PAGE_SHIFT);
 }
 
 void __cpuinit zap_low_mappings(int cpu)
@@ -393,6 +434,9 @@ size_zones(unsigned long *z, unsigned long *h,
 void __init paging_init(void)
 {
         unsigned long zones[MAX_NR_ZONES], holes[MAX_NR_ZONES];
+
+        memory_present(0, 0, end_pfn);
+        sparse_init();
         size_zones(zones, holes, 0, end_pfn);
         free_area_init_node(0, NODE_DATA(0), zones,
                             __pa(PAGE_OFFSET) >> PAGE_SHIFT, holes);
@@ -433,6 +477,50 @@ void __init clear_kernel_mapping(unsigned long address, unsigned long size)
         __flush_tlb_all();
 } 
 
+/*
+ * Memory hotplug specific functions
+ * These are only for non-NUMA machines right now.
+ */
+#ifdef CONFIG_MEMORY_HOTPLUG
+
+void online_page(struct page *page)
+{
+        ClearPageReserved(page);
+        set_page_count(page, 1);
+        __free_page(page);
+        totalram_pages++;
+        num_physpages++;
+}
+
+int add_memory(u64 start, u64 size)
+{
+        struct pglist_data *pgdat = NODE_DATA(0);
+        struct zone *zone = pgdat->node_zones + MAX_NR_ZONES-2;
+        unsigned long start_pfn = start >> PAGE_SHIFT;
+        unsigned long nr_pages = size >> PAGE_SHIFT;
+        int ret;
+
+        ret = __add_pages(zone, start_pfn, nr_pages);
+        if (ret)
+                goto error;
+
+        init_memory_mapping(start, (start + size -1));
+
+        return ret;
+error:
+        printk("%s: Problem encountered in __add_pages!\n", __func__);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(add_memory);
+
+int remove_memory(u64 start, u64 size)
+{
+        return -EINVAL;
+}
+EXPORT_SYMBOL_GPL(remove_memory);
+
+#endif
+
 static struct kcore_list kcore_mem, kcore_vmalloc, kcore_kernel, kcore_modules,
                          kcore_vsyscall;
 
@@ -539,7 +627,7 @@ void mark_rodata_ro(void)
 #ifdef CONFIG_BLK_DEV_INITRD
 void free_initrd_mem(unsigned long start, unsigned long end)
 {
-        if (start < (unsigned long)&_end)
+        if (start >= end)
                 return;
         printk ("Freeing initrd memory: %ldk freed\n", (end - start) >> 10);
         for (; start < end; start += PAGE_SIZE) {
diff --git a/arch/x86_64/mm/mmap.c b/arch/x86_64/mm/mmap.c
new file mode 100644
index 000000000000..43e9b99bdf25
--- /dev/null
+++ b/arch/x86_64/mm/mmap.c
@@ -0,0 +1,30 @@
+/* Copyright 2005 Andi Kleen, SuSE Labs.
+ * Licensed under GPL, v.2
+ */
+#include <linux/config.h>
+#include <linux/mm.h>
+#include <linux/sched.h>
+#include <linux/random.h>
+#include <asm/ia32.h>
+
+/* Notebook: move the mmap code from sys_x86_64.c over here. */
+
+void arch_pick_mmap_layout(struct mm_struct *mm)
+{
+#ifdef CONFIG_IA32_EMULATION
+        if (current_thread_info()->flags & _TIF_IA32)
+                return ia32_pick_mmap_layout(mm);
+#endif
+        mm->mmap_base = TASK_UNMAPPED_BASE;
+        if (current->flags & PF_RANDOMIZE) {
+                /* Add 28bit randomness which is about 40bits of address space
+                   because mmap base has to be page aligned.
+                   or ~1/128 of the total user VM
+                   (total user address space is 47bits) */
+                unsigned rnd = get_random_int() & 0xfffffff;
+                mm->mmap_base += ((unsigned long)rnd) << PAGE_SHIFT;
+        }
+        mm->get_unmapped_area = arch_get_unmapped_area;
+        mm->unmap_area = arch_unmap_area;
+}
+